[SETUPAPI]
[reactos.git] / reactos / dll / win32 / setupapi / install.c
1 /*
2 * Setupapi install routines
3 *
4 * Copyright 2002 Alexandre Julliard for CodeWeavers
5 * 2005-2006 Hervé Poussineau (hpoussin@reactos.org)
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "setupapi_private.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
25
26 /* Unicode constants */
27 static const WCHAR BackSlash[] = {'\\',0};
28 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};
29 static const WCHAR InfDirectory[] = {'i','n','f','\\',0};
30 static const WCHAR OemFileMask[] = {'o','e','m','*','.','i','n','f',0};
31 static const WCHAR OemFileSpecification[] = {'o','e','m','%','l','u','.','i','n','f',0};
32 static const WCHAR DotLnk[] = {'.','l','n','k',0};
33 static const WCHAR DotServices[] = {'.','S','e','r','v','i','c','e','s',0};
34
35 static const WCHAR DependenciesKey[] = {'D','e','p','e','n','d','e','n','c','i','e','s',0};
36 static const WCHAR DescriptionKey[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
37 static const WCHAR DisplayNameKey[] = {'D','i','s','p','l','a','y','N','a','m','e',0};
38 static const WCHAR ErrorControlKey[] = {'E','r','r','o','r','C','o','n','t','r','o','l',0};
39 static const WCHAR LoadOrderGroupKey[] = {'L','o','a','d','O','r','d','e','r','G','r','o','u','p',0};
40 static const WCHAR SecurityKey[] = {'S','e','c','u','r','i','t','y',0};
41 static const WCHAR ServiceBinaryKey[] = {'S','e','r','v','i','c','e','B','i','n','a','r','y',0};
42 static const WCHAR ServiceTypeKey[] = {'S','e','r','v','i','c','e','T','y','p','e',0};
43 static const WCHAR StartTypeKey[] = {'S','t','a','r','t','T','y','p','e',0};
44
45 static const WCHAR Name[] = {'N','a','m','e',0};
46 static const WCHAR CmdLine[] = {'C','m','d','L','i','n','e',0};
47 static const WCHAR SubDir[] = {'S','u','b','D','i','r',0};
48 static const WCHAR WorkingDir[] = {'W','o','r','k','i','n','g','D','i','r',0};
49 static const WCHAR IconPath[] = {'I','c','o','n','P','a','t','h',0};
50 static const WCHAR IconIndex[] = {'I','c','o','n','I','n','d','e','x',0};
51 static const WCHAR HotKey[] = {'H','o','t','K','e','y',0};
52 static const WCHAR InfoTip[] = {'I','n','f','o','T','i','p',0};
53 static const WCHAR DisplayResource[] = {'D','i','s','p','l','a','y','R','e','s','o','u','r','c','e',0};
54
55 /* info passed to callback functions dealing with files */
56 struct files_callback_info
57 {
58 HSPFILEQ queue;
59 PCWSTR src_root;
60 UINT copy_flags;
61 HINF layout;
62 };
63
64 /* info passed to callback functions dealing with the registry */
65 struct registry_callback_info
66 {
67 HKEY default_root;
68 BOOL delete;
69 };
70
71 /* info passed to callback functions dealing with registering dlls */
72 struct register_dll_info
73 {
74 PSP_FILE_CALLBACK_W callback;
75 PVOID callback_context;
76 BOOL unregister;
77 };
78
79 /* info passed to callback functions dealing with Needs directives */
80 struct needs_callback_info
81 {
82 UINT type;
83
84 HWND owner;
85 UINT flags;
86 HKEY key_root;
87 LPCWSTR src_root;
88 UINT copy_flags;
89 PVOID callback;
90 PVOID context;
91 HDEVINFO devinfo;
92 PSP_DEVINFO_DATA devinfo_data;
93 PVOID reserved1;
94 PVOID reserved2;
95 };
96
97 typedef BOOL (*iterate_fields_func)( HINF hinf, PCWSTR field, void *arg );
98 static BOOL GetLineText( HINF hinf, PCWSTR section_name, PCWSTR key_name, PWSTR *value);
99 typedef HRESULT (WINAPI *COINITIALIZE)(IN LPVOID pvReserved);
100 typedef HRESULT (WINAPI *COCREATEINSTANCE)(IN REFCLSID rclsid, IN LPUNKNOWN pUnkOuter, IN DWORD dwClsContext, IN REFIID riid, OUT LPVOID *ppv);
101 typedef HRESULT (WINAPI *COUNINITIALIZE)(VOID);
102
103 /* Unicode constants */
104 static const WCHAR AddService[] = {'A','d','d','S','e','r','v','i','c','e',0};
105 static const WCHAR CopyFiles[] = {'C','o','p','y','F','i','l','e','s',0};
106 static const WCHAR DelFiles[] = {'D','e','l','F','i','l','e','s',0};
107 static const WCHAR RenFiles[] = {'R','e','n','F','i','l','e','s',0};
108 static const WCHAR Ini2Reg[] = {'I','n','i','2','R','e','g',0};
109 static const WCHAR LogConf[] = {'L','o','g','C','o','n','f',0};
110 static const WCHAR AddReg[] = {'A','d','d','R','e','g',0};
111 static const WCHAR DelReg[] = {'D','e','l','R','e','g',0};
112 static const WCHAR BitReg[] = {'B','i','t','R','e','g',0};
113 static const WCHAR UpdateInis[] = {'U','p','d','a','t','e','I','n','i','s',0};
114 static const WCHAR CopyINF[] = {'C','o','p','y','I','N','F',0};
115 static const WCHAR UpdateIniFields[] = {'U','p','d','a','t','e','I','n','i','F','i','e','l','d','s',0};
116 static const WCHAR RegisterDlls[] = {'R','e','g','i','s','t','e','r','D','l','l','s',0};
117 static const WCHAR UnregisterDlls[] = {'U','n','r','e','g','i','s','t','e','r','D','l','l','s',0};
118 static const WCHAR ProfileItems[] = {'P','r','o','f','i','l','e','I','t','e','m','s',0};
119 static const WCHAR Include[] = {'I','n','c','l','u','d','e',0};
120 static const WCHAR Needs[] = {'N','e','e','d','s',0};
121 static const WCHAR DotSecurity[] = {'.','S','e','c','u','r','i','t','y',0};
122 #ifdef __WINESRC__
123 static const WCHAR WineFakeDlls[] = {'W','i','n','e','F','a','k','e','D','l','l','s',0};
124 #endif
125
126
127 /***********************************************************************
128 * get_field_string
129 *
130 * Retrieve the contents of a field, dynamically growing the buffer if necessary.
131 */
132 static WCHAR *get_field_string( INFCONTEXT *context, DWORD index, WCHAR *buffer,
133 WCHAR *static_buffer, DWORD *size )
134 {
135 DWORD required;
136
137 if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
138 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
139 {
140 /* now grow the buffer */
141 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
142 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, required*sizeof(WCHAR) ))) return NULL;
143 *size = required;
144 if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
145 }
146 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
147 return NULL;
148 }
149
150
151 /***********************************************************************
152 * copy_files_callback
153 *
154 * Called once for each CopyFiles entry in a given section.
155 */
156 static BOOL copy_files_callback( HINF hinf, PCWSTR field, void *arg )
157 {
158 struct files_callback_info *info = arg;
159
160 if (field[0] == '@') /* special case: copy single file */
161 SetupQueueDefaultCopyW( info->queue, info->layout ? info->layout : hinf, info->src_root, NULL, field+1, info->copy_flags );
162 else
163 SetupQueueCopySectionW( info->queue, info->src_root, info->layout ? info->layout : hinf, hinf, field, info->copy_flags );
164 return TRUE;
165 }
166
167
168 /***********************************************************************
169 * delete_files_callback
170 *
171 * Called once for each DelFiles entry in a given section.
172 */
173 static BOOL delete_files_callback( HINF hinf, PCWSTR field, void *arg )
174 {
175 struct files_callback_info *info = arg;
176 SetupQueueDeleteSectionW( info->queue, hinf, 0, field );
177 return TRUE;
178 }
179
180
181 /***********************************************************************
182 * rename_files_callback
183 *
184 * Called once for each RenFiles entry in a given section.
185 */
186 static BOOL rename_files_callback( HINF hinf, PCWSTR field, void *arg )
187 {
188 struct files_callback_info *info = arg;
189 SetupQueueRenameSectionW( info->queue, hinf, 0, field );
190 return TRUE;
191 }
192
193
194 /***********************************************************************
195 * get_root_key
196 *
197 * Retrieve the registry root key from its name.
198 */
199 static HKEY get_root_key( const WCHAR *name, HKEY def_root )
200 {
201 static const WCHAR HKCR[] = {'H','K','C','R',0};
202 static const WCHAR HKCU[] = {'H','K','C','U',0};
203 static const WCHAR HKLM[] = {'H','K','L','M',0};
204 static const WCHAR HKU[] = {'H','K','U',0};
205 static const WCHAR HKR[] = {'H','K','R',0};
206
207 if (!strcmpiW( name, HKCR )) return HKEY_CLASSES_ROOT;
208 if (!strcmpiW( name, HKCU )) return HKEY_CURRENT_USER;
209 if (!strcmpiW( name, HKLM )) return HKEY_LOCAL_MACHINE;
210 if (!strcmpiW( name, HKU )) return HKEY_USERS;
211 if (!strcmpiW( name, HKR )) return def_root;
212 return 0;
213 }
214
215
216 /***********************************************************************
217 * append_multi_sz_value
218 *
219 * Append a multisz string to a multisz registry value.
220 */
221 static void append_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *strings,
222 DWORD str_size )
223 {
224 DWORD size, type, total;
225 WCHAR *buffer, *p;
226
227 if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
228 if (type != REG_MULTI_SZ) return;
229
230 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (size + str_size) * sizeof(WCHAR) ))) return;
231 if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
232
233 /* compare each string against all the existing ones */
234 total = size;
235 while (*strings)
236 {
237 int len = strlenW(strings) + 1;
238
239 for (p = buffer; *p; p += strlenW(p) + 1)
240 if (!strcmpiW( p, strings )) break;
241
242 if (!*p) /* not found, need to append it */
243 {
244 memcpy( p, strings, len * sizeof(WCHAR) );
245 p[len] = 0;
246 total += len;
247 }
248 strings += len;
249 }
250 if (total != size)
251 {
252 TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer) );
253 RegSetValueExW( hkey, value, 0, REG_MULTI_SZ, (BYTE *)buffer, total + sizeof(WCHAR) );
254 }
255 done:
256 HeapFree( GetProcessHeap(), 0, buffer );
257 }
258
259
260 /***********************************************************************
261 * delete_multi_sz_value
262 *
263 * Remove a string from a multisz registry value.
264 */
265 static void delete_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *string )
266 {
267 DWORD size, type;
268 WCHAR *buffer, *src, *dst;
269
270 if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
271 if (type != REG_MULTI_SZ) return;
272 /* allocate double the size, one for value before and one for after */
273 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size * 2 * sizeof(WCHAR) ))) return;
274 if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
275 src = buffer;
276 dst = buffer + size;
277 while (*src)
278 {
279 int len = strlenW(src) + 1;
280 if (strcmpiW( src, string ))
281 {
282 memcpy( dst, src, len * sizeof(WCHAR) );
283 dst += len;
284 }
285 src += len;
286 }
287 *dst++ = 0;
288 if (dst != buffer + 2*size) /* did we remove something? */
289 {
290 TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer + size) );
291 RegSetValueExW( hkey, value, 0, REG_MULTI_SZ,
292 (BYTE *)(buffer + size), dst - (buffer + size) );
293 }
294 done:
295 HeapFree( GetProcessHeap(), 0, buffer );
296 }
297
298
299 /***********************************************************************
300 * do_reg_operation
301 *
302 * Perform an add/delete registry operation depending on the flags.
303 */
304 static BOOL do_reg_operation( HKEY hkey, const WCHAR *value, INFCONTEXT *context, INT flags )
305 {
306 DWORD type, size;
307
308 if (flags & (FLG_ADDREG_DELREG_BIT | FLG_ADDREG_DELVAL)) /* deletion */
309 {
310 if (*value && !(flags & FLG_DELREG_KEYONLY_COMMON))
311 {
312 if ((flags & FLG_DELREG_MULTI_SZ_DELSTRING) == FLG_DELREG_MULTI_SZ_DELSTRING)
313 {
314 WCHAR *str;
315
316 if (!SetupGetStringFieldW( context, 5, NULL, 0, &size ) || !size) return TRUE;
317 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
318 SetupGetStringFieldW( context, 5, str, size, NULL );
319 delete_multi_sz_value( hkey, value, str );
320 HeapFree( GetProcessHeap(), 0, str );
321 }
322 else RegDeleteValueW( hkey, value );
323 }
324 else NtDeleteKey( hkey );
325 return TRUE;
326 }
327
328 if (flags & (FLG_ADDREG_KEYONLY|FLG_ADDREG_KEYONLY_COMMON)) return TRUE;
329
330 if (flags & (FLG_ADDREG_NOCLOBBER|FLG_ADDREG_OVERWRITEONLY))
331 {
332 BOOL exists = !RegQueryValueExW( hkey, value, NULL, NULL, NULL, NULL );
333 if (exists && (flags & FLG_ADDREG_NOCLOBBER)) return TRUE;
334 if (!exists && (flags & FLG_ADDREG_OVERWRITEONLY)) return TRUE;
335 }
336
337 switch(flags & FLG_ADDREG_TYPE_MASK)
338 {
339 case FLG_ADDREG_TYPE_SZ: type = REG_SZ; break;
340 case FLG_ADDREG_TYPE_MULTI_SZ: type = REG_MULTI_SZ; break;
341 case FLG_ADDREG_TYPE_EXPAND_SZ: type = REG_EXPAND_SZ; break;
342 case FLG_ADDREG_TYPE_BINARY: type = REG_BINARY; break;
343 case FLG_ADDREG_TYPE_DWORD: type = REG_DWORD; break;
344 case FLG_ADDREG_TYPE_NONE: type = REG_NONE; break;
345 default: type = flags >> 16; break;
346 }
347
348 if (!(flags & FLG_ADDREG_BINVALUETYPE) ||
349 (type == REG_DWORD && SetupGetFieldCount(context) == 5))
350 {
351 static const WCHAR empty;
352 WCHAR *str = NULL;
353
354 if (type == REG_MULTI_SZ)
355 {
356 if (!SetupGetMultiSzFieldW( context, 5, NULL, 0, &size )) size = 0;
357 if (size)
358 {
359 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
360 SetupGetMultiSzFieldW( context, 5, str, size, NULL );
361 }
362 if (flags & FLG_ADDREG_APPEND)
363 {
364 if (!str) return TRUE;
365 append_multi_sz_value( hkey, value, str, size );
366 HeapFree( GetProcessHeap(), 0, str );
367 return TRUE;
368 }
369 /* else fall through to normal string handling */
370 }
371 else
372 {
373 if (!SetupGetStringFieldW( context, 5, NULL, 0, &size )) size = 0;
374 if (size)
375 {
376 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
377 SetupGetStringFieldW( context, 5, str, size, NULL );
378 }
379 }
380
381 if (type == REG_DWORD)
382 {
383 DWORD dw = str ? strtoulW( str, NULL, 0 ) : 0;
384 TRACE( "setting dword %s to %x\n", debugstr_w(value), dw );
385 RegSetValueExW( hkey, value, 0, type, (BYTE *)&dw, sizeof(dw) );
386 }
387 else
388 {
389 TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(str) );
390 if (str) RegSetValueExW( hkey, value, 0, type, (BYTE *)str, size * sizeof(WCHAR) );
391 else RegSetValueExW( hkey, value, 0, type, (const BYTE *)&empty, sizeof(WCHAR) );
392 }
393 HeapFree( GetProcessHeap(), 0, str );
394 return TRUE;
395 }
396 else /* get the binary data */
397 {
398 BYTE *data = NULL;
399
400 if (!SetupGetBinaryField( context, 5, NULL, 0, &size )) size = 0;
401 if (size)
402 {
403 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
404 TRACE( "setting binary data %s len %d\n", debugstr_w(value), size );
405 SetupGetBinaryField( context, 5, data, size, NULL );
406 }
407 RegSetValueExW( hkey, value, 0, type, data, size );
408 HeapFree( GetProcessHeap(), 0, data );
409 return TRUE;
410 }
411 }
412
413
414 /***********************************************************************
415 * registry_callback
416 *
417 * Called once for each AddReg and DelReg entry in a given section.
418 */
419 static BOOL registry_callback( HINF hinf, PCWSTR field, void *arg )
420 {
421 struct registry_callback_info *info = arg;
422 LPWSTR security_key, security_descriptor;
423 INFCONTEXT context, security_context;
424 PSECURITY_DESCRIPTOR sd = NULL;
425 SECURITY_ATTRIBUTES security_attributes = { 0, };
426 HKEY root_key, hkey;
427 DWORD required;
428
429 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
430 if (!ok)
431 return TRUE;
432
433 /* Check for .Security section */
434 security_key = MyMalloc( (strlenW( field ) + strlenW( DotSecurity )) * sizeof(WCHAR) + sizeof(UNICODE_NULL) );
435 if (!security_key)
436 {
437 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
438 return FALSE;
439 }
440 strcpyW( security_key, field );
441 strcatW( security_key, DotSecurity );
442 ok = SetupFindFirstLineW( hinf, security_key, NULL, &security_context );
443 MyFree(security_key);
444 if (ok)
445 {
446 if (!SetupGetLineTextW( &security_context, NULL, NULL, NULL, NULL, 0, &required ))
447 return FALSE;
448 security_descriptor = MyMalloc( required * sizeof(WCHAR) );
449 if (!security_descriptor)
450 {
451 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
452 return FALSE;
453 }
454 if (!SetupGetLineTextW( &security_context, NULL, NULL, NULL, security_descriptor, required, NULL ))
455 return FALSE;
456 ok = ConvertStringSecurityDescriptorToSecurityDescriptorW( security_descriptor, SDDL_REVISION_1, &sd, NULL );
457 MyFree( security_descriptor );
458 if (!ok)
459 return FALSE;
460 security_attributes.nLength = sizeof(SECURITY_ATTRIBUTES);
461 security_attributes.lpSecurityDescriptor = sd;
462 }
463
464 for (ok = TRUE; ok; ok = SetupFindNextLine( &context, &context ))
465 {
466 WCHAR buffer[MAX_INF_STRING_LENGTH];
467 INT flags;
468
469 /* get root */
470 if (!SetupGetStringFieldW( &context, 1, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
471 continue;
472 if (!(root_key = get_root_key( buffer, info->default_root )))
473 continue;
474
475 /* get key */
476 if (!SetupGetStringFieldW( &context, 2, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
477 *buffer = 0;
478
479 /* get flags */
480 if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
481
482 if (!info->delete)
483 {
484 if (flags & FLG_ADDREG_DELREG_BIT) continue; /* ignore this entry */
485 }
486 else
487 {
488 if (!flags) flags = FLG_ADDREG_DELREG_BIT;
489 else if (!(flags & FLG_ADDREG_DELREG_BIT)) continue; /* ignore this entry */
490 }
491
492 if (info->delete || (flags & FLG_ADDREG_OVERWRITEONLY))
493 {
494 if (RegOpenKeyW( root_key, buffer, &hkey )) continue; /* ignore if it doesn't exist */
495 }
496 else if (RegCreateKeyExW( root_key, buffer, 0, NULL, 0, MAXIMUM_ALLOWED,
497 sd ? &security_attributes : NULL, &hkey, NULL ))
498 {
499 ERR( "could not create key %p %s\n", root_key, debugstr_w(buffer) );
500 continue;
501 }
502 TRACE( "key %p %s\n", root_key, debugstr_w(buffer) );
503
504 /* get value name */
505 if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
506 *buffer = 0;
507
508 /* and now do it */
509 if (!do_reg_operation( hkey, buffer, &context, flags ))
510 {
511 if (hkey != root_key) RegCloseKey( hkey );
512 if (sd) LocalFree( sd );
513 return FALSE;
514 }
515 if (hkey != root_key) RegCloseKey( hkey );
516 }
517 if (sd) LocalFree( sd );
518 return TRUE;
519 }
520
521
522 /***********************************************************************
523 * do_register_dll
524 *
525 * Register or unregister a dll.
526 */
527 static BOOL do_register_dll( const struct register_dll_info *info, const WCHAR *path,
528 INT flags, INT timeout, const WCHAR *args )
529 {
530 HMODULE module;
531 HRESULT res;
532 SP_REGISTER_CONTROL_STATUSW status;
533 #ifdef __WINESRC__
534 IMAGE_NT_HEADERS *nt;
535 #endif
536
537 status.cbSize = sizeof(status);
538 status.FileName = path;
539 status.FailureCode = SPREG_SUCCESS;
540 status.Win32Error = ERROR_SUCCESS;
541
542 if (info->callback)
543 {
544 switch(info->callback( info->callback_context, SPFILENOTIFY_STARTREGISTRATION,
545 (UINT_PTR)&status, !info->unregister ))
546 {
547 case FILEOP_ABORT:
548 SetLastError( ERROR_OPERATION_ABORTED );
549 return FALSE;
550 case FILEOP_SKIP:
551 return TRUE;
552 case FILEOP_DOIT:
553 break;
554 }
555 }
556
557 if (!(module = LoadLibraryExW( path, 0, LOAD_WITH_ALTERED_SEARCH_PATH )))
558 {
559 WARN( "could not load %s\n", debugstr_w(path) );
560 status.FailureCode = SPREG_LOADLIBRARY;
561 status.Win32Error = GetLastError();
562 goto done;
563 }
564
565 #ifdef __WINESRC__
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 #endif // __WINESRC__
605
606 if (flags & FLG_REGSVR_DLLREGISTER)
607 {
608 const char *entry_point = info->unregister ? "DllUnregisterServer" : "DllRegisterServer";
609 HRESULT (WINAPI *func)(void) = (void *)GetProcAddress( module, entry_point );
610
611 if (!func)
612 {
613 status.FailureCode = SPREG_GETPROCADDR;
614 status.Win32Error = GetLastError();
615 goto done;
616 }
617
618 TRACE( "calling %s in %s\n", entry_point, debugstr_w(path) );
619 res = func();
620
621 if (FAILED(res))
622 {
623 WARN( "calling %s in %s returned error %x\n", entry_point, debugstr_w(path), res );
624 status.FailureCode = SPREG_REGSVR;
625 status.Win32Error = res;
626 goto done;
627 }
628 }
629
630 if (flags & FLG_REGSVR_DLLINSTALL)
631 {
632 HRESULT (WINAPI *func)(BOOL,LPCWSTR) = (void *)GetProcAddress( module, "DllInstall" );
633
634 if (!func)
635 {
636 status.FailureCode = SPREG_GETPROCADDR;
637 status.Win32Error = GetLastError();
638 goto done;
639 }
640
641 TRACE( "calling DllInstall(%d,%s) in %s\n",
642 !info->unregister, debugstr_w(args), debugstr_w(path) );
643 res = func( !info->unregister, args );
644
645 if (FAILED(res))
646 {
647 WARN( "calling DllInstall in %s returned error %x\n", debugstr_w(path), res );
648 status.FailureCode = SPREG_REGSVR;
649 status.Win32Error = res;
650 goto done;
651 }
652 }
653
654 done:
655 if (module) FreeLibrary( module );
656 if (info->callback) info->callback( info->callback_context, SPFILENOTIFY_ENDREGISTRATION,
657 (UINT_PTR)&status, !info->unregister );
658 return TRUE;
659 }
660
661
662 /***********************************************************************
663 * register_dlls_callback
664 *
665 * Called once for each RegisterDlls entry in a given section.
666 */
667 static BOOL register_dlls_callback( HINF hinf, PCWSTR field, void *arg )
668 {
669 struct register_dll_info *info = arg;
670 INFCONTEXT context;
671 BOOL ret = TRUE;
672 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
673
674 for (; ok; ok = SetupFindNextLine( &context, &context ))
675 {
676 WCHAR *path, *args, *p;
677 WCHAR buffer[MAX_INF_STRING_LENGTH];
678 INT flags, timeout;
679
680 /* get directory */
681 if (!(path = PARSER_get_dest_dir( &context ))) continue;
682
683 /* get dll name */
684 if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
685 goto done;
686 if (!(p = HeapReAlloc( GetProcessHeap(), 0, path,
687 (strlenW(path) + strlenW(buffer) + 2) * sizeof(WCHAR) ))) goto done;
688 path = p;
689 p += strlenW(p);
690 if (p == path || p[-1] != '\\') *p++ = '\\';
691 strcpyW( p, buffer );
692
693 /* get flags */
694 if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
695
696 /* get timeout */
697 if (!SetupGetIntField( &context, 5, &timeout )) timeout = 60;
698
699 /* get command line */
700 args = NULL;
701 if (SetupGetStringFieldW( &context, 6, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
702 args = buffer;
703
704 ret = do_register_dll( info, path, flags, timeout, args );
705
706 done:
707 HeapFree( GetProcessHeap(), 0, path );
708 if (!ret) break;
709 }
710 return ret;
711 }
712
713 #ifdef __WINESRC__
714 /***********************************************************************
715 * fake_dlls_callback
716 *
717 * Called once for each WineFakeDlls entry in a given section.
718 */
719 static BOOL fake_dlls_callback( HINF hinf, PCWSTR field, void *arg )
720 {
721 INFCONTEXT context;
722 BOOL ret = TRUE;
723 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
724
725 for (; ok; ok = SetupFindNextLine( &context, &context ))
726 {
727 WCHAR *path, *p;
728 WCHAR buffer[MAX_INF_STRING_LENGTH];
729
730 /* get directory */
731 if (!(path = PARSER_get_dest_dir( &context ))) continue;
732
733 /* get dll name */
734 if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
735 goto done;
736 if (!(p = HeapReAlloc( GetProcessHeap(), 0, path,
737 (strlenW(path) + strlenW(buffer) + 2) * sizeof(WCHAR) ))) goto done;
738 path = p;
739 p += strlenW(p);
740 if (p == path || p[-1] != '\\') *p++ = '\\';
741 strcpyW( p, buffer );
742
743 /* get source dll */
744 if (SetupGetStringFieldW( &context, 4, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
745 p = buffer; /* otherwise use target base name as default source */
746
747 create_fake_dll( path, p ); /* ignore errors */
748
749 done:
750 HeapFree( GetProcessHeap(), 0, path );
751 if (!ret) break;
752 }
753 return ret;
754 }
755 #endif // __WINESRC__
756
757 /***********************************************************************
758 * update_ini_callback
759 *
760 * Called once for each UpdateInis entry in a given section.
761 */
762 static BOOL update_ini_callback( HINF hinf, PCWSTR field, void *arg )
763 {
764 INFCONTEXT context;
765
766 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
767
768 for (; ok; ok = SetupFindNextLine( &context, &context ))
769 {
770 WCHAR buffer[MAX_INF_STRING_LENGTH];
771 WCHAR filename[MAX_INF_STRING_LENGTH];
772 WCHAR section[MAX_INF_STRING_LENGTH];
773 WCHAR entry[MAX_INF_STRING_LENGTH];
774 WCHAR string[MAX_INF_STRING_LENGTH];
775 LPWSTR divider;
776
777 if (!SetupGetStringFieldW( &context, 1, filename,
778 sizeof(filename)/sizeof(WCHAR), NULL ))
779 continue;
780
781 if (!SetupGetStringFieldW( &context, 2, section,
782 sizeof(section)/sizeof(WCHAR), NULL ))
783 continue;
784
785 if (!SetupGetStringFieldW( &context, 4, buffer,
786 sizeof(buffer)/sizeof(WCHAR), NULL ))
787 continue;
788
789 divider = strchrW(buffer,'=');
790 if (divider)
791 {
792 *divider = 0;
793 strcpyW(entry,buffer);
794 divider++;
795 strcpyW(string,divider);
796 }
797 else
798 {
799 strcpyW(entry,buffer);
800 string[0]=0;
801 }
802
803 TRACE("Writing %s = %s in %s of file %s\n",debugstr_w(entry),
804 debugstr_w(string),debugstr_w(section),debugstr_w(filename));
805 WritePrivateProfileStringW(section,entry,string,filename);
806
807 }
808 return TRUE;
809 }
810
811 static BOOL update_ini_fields_callback( HINF hinf, PCWSTR field, void *arg )
812 {
813 FIXME( "should update ini fields %s\n", debugstr_w(field) );
814 return TRUE;
815 }
816
817 static BOOL ini2reg_callback( HINF hinf, PCWSTR field, void *arg )
818 {
819 FIXME( "should do ini2reg %s\n", debugstr_w(field) );
820 return TRUE;
821 }
822
823 static BOOL logconf_callback( HINF hinf, PCWSTR field, void *arg )
824 {
825 FIXME( "should do logconf %s\n", debugstr_w(field) );
826 return TRUE;
827 }
828
829 static BOOL bitreg_callback( HINF hinf, PCWSTR field, void *arg )
830 {
831 FIXME( "should do bitreg %s\n", debugstr_w(field) );
832 return TRUE;
833 }
834
835 static BOOL Concatenate(int DirId, LPCWSTR SubDirPart, LPCWSTR NamePart, LPWSTR *pFullName)
836 {
837 DWORD dwRequired = 0;
838 LPCWSTR Dir;
839 LPWSTR FullName;
840
841 *pFullName = NULL;
842
843 Dir = DIRID_get_string(DirId);
844 if (Dir)
845 dwRequired += wcslen(Dir) + 1;
846 if (SubDirPart)
847 dwRequired += wcslen(SubDirPart) + 1;
848 if (NamePart)
849 dwRequired += wcslen(NamePart);
850 dwRequired = dwRequired * sizeof(WCHAR) + sizeof(UNICODE_NULL);
851
852 FullName = MyMalloc(dwRequired);
853 if (!FullName)
854 {
855 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
856 return FALSE;
857 }
858 FullName[0] = UNICODE_NULL;
859
860 if (Dir)
861 {
862 wcscat(FullName, Dir);
863 if (FullName[wcslen(FullName) - 1] != '\\')
864 wcscat(FullName, BackSlash);
865 }
866 if (SubDirPart)
867 {
868 wcscat(FullName, SubDirPart);
869 if (FullName[wcslen(FullName) - 1] != '\\')
870 wcscat(FullName, BackSlash);
871 }
872 if (NamePart)
873 wcscat(FullName, NamePart);
874
875 *pFullName = FullName;
876 return TRUE;
877 }
878
879 /***********************************************************************
880 * profile_items_callback
881 *
882 * Called once for each ProfileItems entry in a given section.
883 */
884 static BOOL
885 profile_items_callback(
886 IN HINF hInf,
887 IN PCWSTR SectionName,
888 IN PVOID Arg)
889 {
890 INFCONTEXT Context;
891 LPWSTR LinkSubDir = NULL, LinkName = NULL;
892 INT LinkAttributes = 0;
893 INT LinkFolder = 0;
894 INT FileDirId = 0;
895 INT CSIDL = CSIDL_COMMON_PROGRAMS;
896 LPWSTR FileSubDir = NULL;
897 INT DirId = 0;
898 LPWSTR SubDirPart = NULL, NamePart = NULL;
899 LPWSTR FullLinkName = NULL, FullFileName = NULL, FullWorkingDir = NULL, FullIconName = NULL;
900 INT IconIdx = 0;
901 LPWSTR lpHotKey = NULL, lpInfoTip = NULL;
902 LPWSTR DisplayName = NULL;
903 INT DisplayResId = 0;
904 BOOL ret = FALSE;
905 DWORD Index, Required;
906
907 IShellLinkW *psl;
908 IPersistFile *ppf;
909 HMODULE hOle32 = NULL;
910 COINITIALIZE pCoInitialize;
911 COCREATEINSTANCE pCoCreateInstance;
912 COUNINITIALIZE pCoUninitialize;
913 HRESULT hr;
914
915 TRACE("hInf %p, SectionName %s, Arg %p\n",
916 hInf, debugstr_w(SectionName), Arg);
917
918 /* Read 'Name' entry */
919 if (!SetupFindFirstLineW(hInf, SectionName, Name, &Context))
920 goto cleanup;
921 if (!GetStringField(&Context, 1, &LinkName))
922 goto cleanup;
923 if (SetupGetFieldCount(&Context) >= 2)
924 {
925 if (!SetupGetIntField(&Context, 2, &LinkAttributes))
926 goto cleanup;
927 }
928 if (SetupGetFieldCount(&Context) >= 3)
929 {
930 if (!SetupGetIntField(&Context, 3, &LinkFolder))
931 goto cleanup;
932 }
933
934 /* Read 'CmdLine' entry */
935 if (!SetupFindFirstLineW(hInf, SectionName, CmdLine, &Context))
936 goto cleanup;
937 Index = 1;
938 if (!SetupGetIntField(&Context, Index++, &FileDirId))
939 goto cleanup;
940 if (SetupGetFieldCount(&Context) >= 3)
941 {
942 if (!GetStringField(&Context, Index++, &FileSubDir))
943 goto cleanup;
944 }
945 if (!GetStringField(&Context, Index++, &NamePart))
946 goto cleanup;
947 if (!Concatenate(FileDirId, FileSubDir, NamePart, &FullFileName))
948 goto cleanup;
949 MyFree(NamePart);
950 NamePart = NULL;
951
952 /* Read 'SubDir' entry */
953 if ((LinkAttributes & FLG_PROFITEM_GROUP) == 0 && SetupFindFirstLineW(hInf, SectionName, SubDir, &Context))
954 {
955 if (!GetStringField(&Context, 1, &LinkSubDir))
956 goto cleanup;
957 }
958
959 /* Read 'WorkingDir' entry */
960 if (SetupFindFirstLineW(hInf, SectionName, WorkingDir, &Context))
961 {
962 if (!SetupGetIntField(&Context, 1, &DirId))
963 goto cleanup;
964 if (SetupGetFieldCount(&Context) >= 2)
965 {
966 if (!GetStringField(&Context, 2, &SubDirPart))
967 goto cleanup;
968 }
969 if (!Concatenate(DirId, SubDirPart, NULL, &FullWorkingDir))
970 goto cleanup;
971 MyFree(SubDirPart);
972 SubDirPart = NULL;
973 }
974 else
975 {
976 if (!Concatenate(FileDirId, FileSubDir, NULL, &FullWorkingDir))
977 goto cleanup;
978 }
979
980 /* Read 'IconPath' entry */
981 if (SetupFindFirstLineW(hInf, SectionName, IconPath, &Context))
982 {
983 Index = 1;
984 if (!SetupGetIntField(&Context, Index++, &DirId))
985 goto cleanup;
986 if (SetupGetFieldCount(&Context) >= 3)
987 {
988 if (!GetStringField(&Context, Index++, &SubDirPart))
989 goto cleanup;
990 }
991 if (!GetStringField(&Context, Index, &NamePart))
992 goto cleanup;
993 if (!Concatenate(DirId, SubDirPart, NamePart, &FullIconName))
994 goto cleanup;
995 MyFree(SubDirPart);
996 MyFree(NamePart);
997 SubDirPart = NamePart = NULL;
998 }
999 else
1000 {
1001 FullIconName = pSetupDuplicateString(FullFileName);
1002 if (!FullIconName)
1003 goto cleanup;
1004 }
1005
1006 /* Read 'IconIndex' entry */
1007 if (SetupFindFirstLineW(hInf, SectionName, IconIndex, &Context))
1008 {
1009 if (!SetupGetIntField(&Context, 1, &IconIdx))
1010 goto cleanup;
1011 }
1012
1013 /* Read 'HotKey' and 'InfoTip' entries */
1014 GetLineText(hInf, SectionName, HotKey, &lpHotKey);
1015 GetLineText(hInf, SectionName, InfoTip, &lpInfoTip);
1016
1017 /* Read 'DisplayResource' entry */
1018 if (SetupFindFirstLineW(hInf, SectionName, DisplayResource, &Context))
1019 {
1020 if (!GetStringField(&Context, 1, &DisplayName))
1021 goto cleanup;
1022 if (!SetupGetIntField(&Context, 2, &DisplayResId))
1023 goto cleanup;
1024 }
1025
1026 /* Some debug */
1027 TRACE("Link is %s\\%s, attributes 0x%x\n", debugstr_w(LinkSubDir), debugstr_w(LinkName), LinkAttributes);
1028 TRACE("File is %s\n", debugstr_w(FullFileName));
1029 TRACE("Working dir %s\n", debugstr_w(FullWorkingDir));
1030 TRACE("Icon is %s, %d\n", debugstr_w(FullIconName), IconIdx);
1031 TRACE("Hotkey %s\n", debugstr_w(lpHotKey));
1032 TRACE("InfoTip %s\n", debugstr_w(lpInfoTip));
1033 TRACE("Display %s, %d\n", DisplayName, DisplayResId);
1034
1035 /* Load ole32.dll */
1036 hOle32 = LoadLibraryA("ole32.dll");
1037 if (!hOle32)
1038 goto cleanup;
1039 pCoInitialize = (COINITIALIZE)GetProcAddress(hOle32, "CoInitialize");
1040 if (!pCoInitialize)
1041 goto cleanup;
1042 pCoCreateInstance = (COCREATEINSTANCE)GetProcAddress(hOle32, "CoCreateInstance");
1043 if (!pCoCreateInstance)
1044 goto cleanup;
1045 pCoUninitialize = (COUNINITIALIZE)GetProcAddress(hOle32, "CoUninitialize");
1046 if (!pCoUninitialize)
1047 goto cleanup;
1048
1049 /* Create shortcut */
1050 hr = pCoInitialize(NULL);
1051 if (!SUCCEEDED(hr))
1052 {
1053 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
1054 SetLastError(HRESULT_CODE(hr));
1055 else
1056 SetLastError(E_FAIL);
1057 goto cleanup;
1058 }
1059 hr = pCoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, &IID_IShellLinkW, (LPVOID*)&psl);
1060 if (SUCCEEDED(hr))
1061 {
1062 /* Fill link properties */
1063 if (SUCCEEDED(hr))
1064 hr = IShellLinkW_SetPath(psl, FullFileName);
1065 if (SUCCEEDED(hr))
1066 hr = IShellLinkW_SetArguments(psl, L"");
1067 if (SUCCEEDED(hr))
1068 hr = IShellLinkW_SetWorkingDirectory(psl, FullWorkingDir);
1069 if (SUCCEEDED(hr))
1070 hr = IShellLinkW_SetIconLocation(psl, FullIconName, IconIdx);
1071 if (SUCCEEDED(hr) && lpHotKey)
1072 FIXME("Need to store hotkey %s in shell link\n", debugstr_w(lpHotKey));
1073 if (SUCCEEDED(hr) && lpInfoTip)
1074 hr = IShellLinkW_SetDescription(psl, lpInfoTip);
1075 if (SUCCEEDED(hr) && DisplayName)
1076 FIXME("Need to store display name %s, %d in shell link\n", debugstr_w(DisplayName), DisplayResId);
1077 if (SUCCEEDED(hr))
1078 {
1079 hr = IShellLinkW_QueryInterface(psl, &IID_IPersistFile, (LPVOID*)&ppf);
1080 if (SUCCEEDED(hr))
1081 {
1082 Required = (MAX_PATH + wcslen(LinkSubDir) + 1 + wcslen(LinkName)) * sizeof(WCHAR);
1083 FullLinkName = MyMalloc(Required);
1084 if (!FullLinkName)
1085 hr = E_OUTOFMEMORY;
1086 else
1087 {
1088 if (LinkAttributes & (FLG_PROFITEM_DELETE | FLG_PROFITEM_GROUP))
1089 FIXME("Need to handle FLG_PROFITEM_DELETE and FLG_PROFITEM_GROUP\n");
1090 if (LinkAttributes & FLG_PROFITEM_CSIDL)
1091 CSIDL = LinkFolder;
1092 else if (LinkAttributes & FLG_PROFITEM_CURRENTUSER)
1093 CSIDL = CSIDL_PROGRAMS;
1094
1095 if (SHGetSpecialFolderPathW(
1096 NULL,
1097 FullLinkName,
1098 CSIDL,
1099 TRUE))
1100 {
1101 if (FullLinkName[wcslen(FullLinkName) - 1] != '\\')
1102 wcscat(FullLinkName, BackSlash);
1103 if (LinkSubDir)
1104 {
1105 wcscat(FullLinkName, LinkSubDir);
1106 if (FullLinkName[wcslen(FullLinkName) - 1] != '\\')
1107 wcscat(FullLinkName, BackSlash);
1108 }
1109 wcscat(FullLinkName, LinkName);
1110 wcscat(FullLinkName, DotLnk);
1111 hr = IPersistFile_Save(ppf, FullLinkName, TRUE);
1112 }
1113 else
1114 hr = HRESULT_FROM_WIN32(GetLastError());
1115 }
1116 IPersistFile_Release(ppf);
1117 }
1118 }
1119 IShellLinkW_Release(psl);
1120 }
1121 pCoUninitialize();
1122 if (SUCCEEDED(hr))
1123 ret = TRUE;
1124 else
1125 {
1126 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
1127 SetLastError(HRESULT_CODE(hr));
1128 else
1129 SetLastError(E_FAIL);
1130 }
1131
1132 cleanup:
1133 MyFree(LinkSubDir);
1134 MyFree(LinkName);
1135 MyFree(FileSubDir);
1136 MyFree(SubDirPart);
1137 MyFree(NamePart);
1138 MyFree(FullFileName);
1139 MyFree(FullWorkingDir);
1140 MyFree(FullIconName);
1141 MyFree(FullLinkName);
1142 MyFree(lpHotKey);
1143 MyFree(lpInfoTip);
1144 MyFree(DisplayName);
1145 if (hOle32)
1146 FreeLibrary(hOle32);
1147
1148 TRACE("Returning %d\n", ret);
1149 return ret;
1150 }
1151
1152 static BOOL copy_inf_callback( HINF hinf, PCWSTR field, void *arg )
1153 {
1154 FIXME( "should do copy inf %s\n", debugstr_w(field) );
1155 return TRUE;
1156 }
1157
1158
1159 /***********************************************************************
1160 * iterate_section_fields
1161 *
1162 * Iterate over all fields of a certain key of a certain section
1163 */
1164 static BOOL iterate_section_fields( HINF hinf, PCWSTR section, PCWSTR key,
1165 iterate_fields_func callback, void *arg )
1166 {
1167 WCHAR static_buffer[200];
1168 WCHAR *buffer = static_buffer;
1169 DWORD size = sizeof(static_buffer)/sizeof(WCHAR);
1170 INFCONTEXT context;
1171 BOOL ret = FALSE;
1172
1173 BOOL ok = SetupFindFirstLineW( hinf, section, key, &context );
1174 while (ok)
1175 {
1176 UINT i, count = SetupGetFieldCount( &context );
1177 for (i = 1; i <= count; i++)
1178 {
1179 if (!(buffer = get_field_string( &context, i, buffer, static_buffer, &size )))
1180 goto done;
1181 if (!callback( hinf, buffer, arg ))
1182 {
1183 WARN("callback failed for %s %s err %d\n",
1184 debugstr_w(section), debugstr_w(buffer), GetLastError() );
1185 goto done;
1186 }
1187 }
1188 ok = SetupFindNextMatchLineW( &context, key, &context );
1189 }
1190 ret = TRUE;
1191 done:
1192 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
1193 return ret;
1194 }
1195
1196
1197 /***********************************************************************
1198 * SetupInstallFilesFromInfSectionA (SETUPAPI.@)
1199 */
1200 BOOL WINAPI SetupInstallFilesFromInfSectionA( HINF hinf, HINF hlayout, HSPFILEQ queue,
1201 PCSTR section, PCSTR src_root, UINT flags )
1202 {
1203 UNICODE_STRING sectionW;
1204 BOOL ret = FALSE;
1205
1206 if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
1207 {
1208 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1209 return FALSE;
1210 }
1211 if (!src_root)
1212 ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
1213 NULL, flags );
1214 else
1215 {
1216 UNICODE_STRING srcW;
1217 if (RtlCreateUnicodeStringFromAsciiz( &srcW, src_root ))
1218 {
1219 ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
1220 srcW.Buffer, flags );
1221 RtlFreeUnicodeString( &srcW );
1222 }
1223 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1224 }
1225 RtlFreeUnicodeString( &sectionW );
1226 return ret;
1227 }
1228
1229
1230 /***********************************************************************
1231 * SetupInstallFilesFromInfSectionW (SETUPAPI.@)
1232 */
1233 BOOL WINAPI SetupInstallFilesFromInfSectionW( HINF hinf, HINF hlayout, HSPFILEQ queue,
1234 PCWSTR section, PCWSTR src_root, UINT flags )
1235 {
1236 struct files_callback_info info;
1237
1238 info.queue = queue;
1239 info.src_root = src_root;
1240 info.copy_flags = flags;
1241 info.layout = hlayout;
1242 return iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info );
1243 }
1244
1245
1246 /***********************************************************************
1247 * SetupInstallFromInfSectionA (SETUPAPI.@)
1248 */
1249 BOOL WINAPI SetupInstallFromInfSectionA( HWND owner, HINF hinf, PCSTR section, UINT flags,
1250 HKEY key_root, PCSTR src_root, UINT copy_flags,
1251 PSP_FILE_CALLBACK_A callback, PVOID context,
1252 HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
1253 {
1254 UNICODE_STRING sectionW, src_rootW;
1255 struct callback_WtoA_context ctx;
1256 BOOL ret = FALSE;
1257
1258 src_rootW.Buffer = NULL;
1259 if (src_root && !RtlCreateUnicodeStringFromAsciiz( &src_rootW, src_root ))
1260 {
1261 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1262 return FALSE;
1263 }
1264
1265 if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
1266 {
1267 ctx.orig_context = context;
1268 ctx.orig_handler = callback;
1269 ret = SetupInstallFromInfSectionW( owner, hinf, sectionW.Buffer, flags, key_root,
1270 src_rootW.Buffer, copy_flags, QUEUE_callback_WtoA,
1271 &ctx, devinfo, devinfo_data );
1272 RtlFreeUnicodeString( &sectionW );
1273 }
1274 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1275
1276 RtlFreeUnicodeString( &src_rootW );
1277 return ret;
1278 }
1279
1280
1281 /***********************************************************************
1282 * include_callback
1283 *
1284 * Called once for each Include entry in a given section.
1285 */
1286 static BOOL include_callback( HINF hinf, PCWSTR field, void *arg )
1287 {
1288 return SetupOpenAppendInfFileW( field, hinf, NULL );
1289 }
1290
1291
1292 /***********************************************************************
1293 * needs_callback
1294 *
1295 * Called once for each Needs entry in a given section.
1296 */
1297 static BOOL needs_callback( HINF hinf, PCWSTR field, void *arg )
1298 {
1299 struct needs_callback_info *info = arg;
1300
1301 switch (info->type)
1302 {
1303 case 0:
1304 return SetupInstallFromInfSectionW(info->owner, *(HINF*)hinf, field, info->flags,
1305 info->key_root, info->src_root, info->copy_flags, info->callback,
1306 info->context, info->devinfo, info->devinfo_data);
1307 case 1:
1308 return SetupInstallServicesFromInfSectionExW(*(HINF*)hinf, field, info->flags,
1309 info->devinfo, info->devinfo_data, info->reserved1, info->reserved2);
1310 default:
1311 ERR("Unknown info type %u\n", info->type);
1312 return FALSE;
1313 }
1314 }
1315
1316
1317 /***********************************************************************
1318 * SetupInstallFromInfSectionW (SETUPAPI.@)
1319 */
1320 BOOL WINAPI SetupInstallFromInfSectionW( HWND owner, HINF hinf, PCWSTR section, UINT flags,
1321 HKEY key_root, PCWSTR src_root, UINT copy_flags,
1322 PSP_FILE_CALLBACK_W callback, PVOID context,
1323 HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
1324 {
1325 struct needs_callback_info needs_info;
1326
1327 /* Parse 'Include' and 'Needs' directives */
1328 iterate_section_fields( hinf, section, Include, include_callback, NULL);
1329 needs_info.type = 0;
1330 needs_info.owner = owner;
1331 needs_info.flags = flags;
1332 needs_info.key_root = key_root;
1333 needs_info.src_root = src_root;
1334 needs_info.copy_flags = copy_flags;
1335 needs_info.callback = callback;
1336 needs_info.context = context;
1337 needs_info.devinfo = devinfo;
1338 needs_info.devinfo_data = devinfo_data;
1339 iterate_section_fields( hinf, section, Needs, needs_callback, &needs_info);
1340
1341 if (flags & SPINST_FILES)
1342 {
1343 SP_DEVINSTALL_PARAMS_W install_params;
1344 struct files_callback_info info;
1345 HSPFILEQ queue = NULL;
1346 BOOL use_custom_queue;
1347 BOOL ret;
1348
1349 install_params.cbSize = sizeof(SP_DEVINSTALL_PARAMS);
1350 use_custom_queue = SetupDiGetDeviceInstallParamsW(devinfo, devinfo_data, &install_params) && (install_params.Flags & DI_NOVCP);
1351 if (!use_custom_queue && ((queue = SetupOpenFileQueue()) == (HSPFILEQ)INVALID_HANDLE_VALUE ))
1352 return FALSE;
1353 info.queue = use_custom_queue ? install_params.FileQueue : queue;
1354 info.src_root = src_root;
1355 info.copy_flags = copy_flags;
1356 info.layout = hinf;
1357 ret = (iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info ) &&
1358 iterate_section_fields( hinf, section, DelFiles, delete_files_callback, &info ) &&
1359 iterate_section_fields( hinf, section, RenFiles, rename_files_callback, &info ));
1360 if (!use_custom_queue)
1361 {
1362 if (ret)
1363 ret = SetupCommitFileQueueW( owner, queue, callback, context );
1364 SetupCloseFileQueue( queue );
1365 }
1366 if (!ret) return FALSE;
1367 }
1368 if (flags & SPINST_INIFILES)
1369 {
1370 if (!iterate_section_fields( hinf, section, UpdateInis, update_ini_callback, NULL ) ||
1371 !iterate_section_fields( hinf, section, UpdateIniFields,
1372 update_ini_fields_callback, NULL ))
1373 return FALSE;
1374 }
1375 if (flags & SPINST_INI2REG)
1376 {
1377 if (!iterate_section_fields( hinf, section, Ini2Reg, ini2reg_callback, NULL ))
1378 return FALSE;
1379 }
1380 if (flags & SPINST_LOGCONFIG)
1381 {
1382 if (!iterate_section_fields( hinf, section, LogConf, logconf_callback, NULL ))
1383 return FALSE;
1384 }
1385 if (flags & SPINST_REGSVR)
1386 {
1387 struct register_dll_info info;
1388
1389 info.unregister = FALSE;
1390 if (flags & SPINST_REGISTERCALLBACKAWARE)
1391 {
1392 info.callback = callback;
1393 info.callback_context = context;
1394 }
1395 else info.callback = NULL;
1396
1397 if (!iterate_section_fields( hinf, section, RegisterDlls, register_dlls_callback, &info ))
1398 return FALSE;
1399
1400 #ifdef __WINESRC__
1401 if (!iterate_section_fields( hinf, section, WineFakeDlls, fake_dlls_callback, NULL ))
1402 return FALSE;
1403 #endif // __WINESRC__
1404 }
1405 if (flags & SPINST_UNREGSVR)
1406 {
1407 struct register_dll_info info;
1408
1409 info.unregister = TRUE;
1410 if (flags & SPINST_REGISTERCALLBACKAWARE)
1411 {
1412 info.callback = callback;
1413 info.callback_context = context;
1414 }
1415 else info.callback = NULL;
1416
1417 if (!iterate_section_fields( hinf, section, UnregisterDlls, register_dlls_callback, &info ))
1418 return FALSE;
1419 }
1420 if (flags & SPINST_REGISTRY)
1421 {
1422 struct registry_callback_info info;
1423
1424 info.default_root = key_root;
1425 info.delete = TRUE;
1426 if (!iterate_section_fields( hinf, section, DelReg, registry_callback, &info ))
1427 return FALSE;
1428 info.delete = FALSE;
1429 if (!iterate_section_fields( hinf, section, AddReg, registry_callback, &info ))
1430 return FALSE;
1431 }
1432 if (flags & SPINST_BITREG)
1433 {
1434 if (!iterate_section_fields( hinf, section, BitReg, bitreg_callback, NULL ))
1435 return FALSE;
1436 }
1437 if (flags & SPINST_PROFILEITEMS)
1438 {
1439 if (!iterate_section_fields( hinf, section, ProfileItems, profile_items_callback, NULL ))
1440 return FALSE;
1441 }
1442 if (flags & SPINST_COPYINF)
1443 {
1444 if (!iterate_section_fields( hinf, section, CopyINF, copy_inf_callback, NULL ))
1445 return FALSE;
1446 }
1447
1448 return TRUE;
1449 }
1450
1451
1452 /***********************************************************************
1453 * InstallHinfSectionW (SETUPAPI.@)
1454 *
1455 * NOTE: 'cmdline' is <section> <mode> <path> from
1456 * RUNDLL32.EXE SETUPAPI.DLL,InstallHinfSection <section> <mode> <path>
1457 */
1458 void WINAPI InstallHinfSectionW( HWND hwnd, HINSTANCE handle, LPCWSTR cmdline, INT show )
1459 {
1460 WCHAR *s, *path, section[MAX_PATH];
1461 void *callback_context = NULL;
1462 DWORD SectionNameLength;
1463 UINT mode;
1464 HINF hinf = INVALID_HANDLE_VALUE;
1465 BOOL bRebootRequired = FALSE;
1466 BOOL ret;
1467
1468 TRACE("hwnd %p, handle %p, cmdline %s\n", hwnd, handle, debugstr_w(cmdline));
1469
1470 lstrcpynW( section, cmdline, MAX_PATH );
1471
1472 if (!(s = strchrW( section, ' ' ))) return;
1473 *s++ = 0;
1474 while (*s == ' ') s++;
1475 mode = atoiW( s );
1476
1477 /* quoted paths are not allowed on native, the rest of the command line is taken as the path */
1478 if (!(s = strchrW( s, ' ' ))) return;
1479 while (*s == ' ') s++;
1480 path = s;
1481
1482 if (mode & 0x80)
1483 {
1484 FIXME("default path of the installation not changed\n");
1485 mode &= ~0x80;
1486 }
1487
1488 hinf = SetupOpenInfFileW( path, NULL, INF_STYLE_WIN4, NULL );
1489 if (hinf == INVALID_HANDLE_VALUE)
1490 {
1491 WARN("SetupOpenInfFileW(%s) failed (Error %u)\n", path, GetLastError());
1492 goto cleanup;
1493 }
1494
1495 ret = SetupDiGetActualSectionToInstallW(
1496 hinf, section, section, sizeof(section)/sizeof(section[0]), &SectionNameLength, NULL );
1497 if (!ret)
1498 {
1499 WARN("SetupDiGetActualSectionToInstallW() failed (Error %u)\n", GetLastError());
1500 goto cleanup;
1501 }
1502 if (SectionNameLength > MAX_PATH - strlenW(DotServices))
1503 {
1504 WARN("Section name '%s' too long\n", section);
1505 goto cleanup;
1506 }
1507
1508 /* Copy files and add registry entries */
1509 callback_context = SetupInitDefaultQueueCallback( hwnd );
1510 ret = SetupInstallFromInfSectionW( hwnd, hinf, section, SPINST_ALL, NULL, NULL,
1511 SP_COPY_NEWER | SP_COPY_IN_USE_NEEDS_REBOOT,
1512 SetupDefaultQueueCallbackW, callback_context,
1513 NULL, NULL );
1514 if (!ret)
1515 {
1516 WARN("SetupInstallFromInfSectionW() failed (Error %u)\n", GetLastError());
1517 goto cleanup;
1518 }
1519 /* FIXME: need to check if some files were in use and need reboot
1520 * bReboot = ...;
1521 */
1522
1523 /* Install services */
1524 wcscat(section, DotServices);
1525 ret = SetupInstallServicesFromInfSectionW( hinf, section, 0 );
1526 if (!ret && GetLastError() == ERROR_SECTION_NOT_FOUND)
1527 ret = TRUE;
1528 if (!ret)
1529 {
1530 WARN("SetupInstallServicesFromInfSectionW() failed (Error %u)\n", GetLastError());
1531 goto cleanup;
1532 }
1533 else if (GetLastError() == ERROR_SUCCESS_REBOOT_REQUIRED)
1534 {
1535 bRebootRequired = TRUE;
1536 }
1537
1538 /* Check if we need to reboot */
1539 switch (mode)
1540 {
1541 case 0:
1542 /* Never reboot */
1543 break;
1544 case 1:
1545 /* Always reboot */
1546 ExitWindowsEx(EWX_REBOOT, SHTDN_REASON_MAJOR_APPLICATION |
1547 SHTDN_REASON_MINOR_INSTALLATION | SHTDN_REASON_FLAG_PLANNED);
1548 break;
1549 case 2:
1550 /* Query user before rebooting */
1551 SetupPromptReboot(NULL, hwnd, FALSE);
1552 break;
1553 case 3:
1554 /* Reboot if necessary */
1555 if (bRebootRequired)
1556 {
1557 ExitWindowsEx(EWX_REBOOT, SHTDN_REASON_MAJOR_APPLICATION |
1558 SHTDN_REASON_MINOR_INSTALLATION | SHTDN_REASON_FLAG_PLANNED);
1559 }
1560 break;
1561 case 4:
1562 /* If necessary, query user before rebooting */
1563 if (bRebootRequired)
1564 {
1565 SetupPromptReboot(NULL, hwnd, FALSE);
1566 }
1567 break;
1568 default:
1569 break;
1570 }
1571
1572 cleanup:
1573 if ( callback_context )
1574 SetupTermDefaultQueueCallback( callback_context );
1575 if ( hinf != INVALID_HANDLE_VALUE )
1576 SetupCloseInfFile( hinf );
1577 }
1578
1579
1580 /***********************************************************************
1581 * InstallHinfSectionA (SETUPAPI.@)
1582 */
1583 void WINAPI InstallHinfSectionA( HWND hwnd, HINSTANCE handle, LPCSTR cmdline, INT show )
1584 {
1585 UNICODE_STRING cmdlineW;
1586
1587 if (RtlCreateUnicodeStringFromAsciiz( &cmdlineW, cmdline ))
1588 {
1589 InstallHinfSectionW( hwnd, handle, cmdlineW.Buffer, show );
1590 RtlFreeUnicodeString( &cmdlineW );
1591 }
1592 }
1593
1594 /***********************************************************************
1595 * SetupInstallServicesFromInfSectionW (SETUPAPI.@)
1596 */
1597 BOOL WINAPI SetupInstallServicesFromInfSectionW( HINF Inf, PCWSTR SectionName, DWORD Flags)
1598 {
1599 return SetupInstallServicesFromInfSectionExW( Inf, SectionName, Flags,
1600 NULL, NULL, NULL, NULL );
1601 }
1602
1603 /***********************************************************************
1604 * SetupInstallServicesFromInfSectionA (SETUPAPI.@)
1605 */
1606 BOOL WINAPI SetupInstallServicesFromInfSectionA( HINF Inf, PCSTR SectionName, DWORD Flags)
1607 {
1608 return SetupInstallServicesFromInfSectionExA( Inf, SectionName, Flags,
1609 NULL, NULL, NULL, NULL );
1610 }
1611
1612 /***********************************************************************
1613 * SetupInstallServicesFromInfSectionExA (SETUPAPI.@)
1614 */
1615 BOOL WINAPI SetupInstallServicesFromInfSectionExA( HINF hinf, PCSTR sectionname, DWORD flags, HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data, PVOID reserved1, PVOID reserved2 )
1616 {
1617 UNICODE_STRING sectionnameW;
1618 BOOL ret = FALSE;
1619
1620 if (RtlCreateUnicodeStringFromAsciiz( &sectionnameW, sectionname ))
1621 {
1622 ret = SetupInstallServicesFromInfSectionExW( hinf, sectionnameW.Buffer, flags, devinfo, devinfo_data, reserved1, reserved2 );
1623 RtlFreeUnicodeString( &sectionnameW );
1624 }
1625 else
1626 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1627
1628 return ret;
1629 }
1630
1631
1632 static BOOL GetLineText( HINF hinf, PCWSTR section_name, PCWSTR key_name, PWSTR *value)
1633 {
1634 DWORD required;
1635 PWSTR buf = NULL;
1636
1637 *value = NULL;
1638
1639 if (! SetupGetLineTextW( NULL, hinf, section_name, key_name, NULL, 0, &required )
1640 && GetLastError() != ERROR_INSUFFICIENT_BUFFER )
1641 return FALSE;
1642
1643 buf = HeapAlloc( GetProcessHeap(), 0, required * sizeof(WCHAR) );
1644 if ( ! buf )
1645 {
1646 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1647 return FALSE;
1648 }
1649
1650 if (! SetupGetLineTextW( NULL, hinf, section_name, key_name, buf, required, &required ) )
1651 {
1652 HeapFree( GetProcessHeap(), 0, buf );
1653 return FALSE;
1654 }
1655
1656 *value = buf;
1657 return TRUE;
1658 }
1659
1660
1661 static BOOL GetIntField( HINF hinf, PCWSTR section_name, PCWSTR key_name, INT *value)
1662 {
1663 LPWSTR buffer, end;
1664 INT res;
1665
1666 if (! GetLineText( hinf, section_name, key_name, &buffer ) )
1667 return FALSE;
1668
1669 res = wcstol( buffer, &end, 0 );
1670 if (end != buffer && !*end)
1671 {
1672 HeapFree(GetProcessHeap(), 0, buffer);
1673 *value = res;
1674 return TRUE;
1675 }
1676 else
1677 {
1678 HeapFree(GetProcessHeap(), 0, buffer);
1679 SetLastError( ERROR_INVALID_DATA );
1680 return FALSE;
1681 }
1682 }
1683
1684
1685 BOOL GetStringField( PINFCONTEXT context, DWORD index, PWSTR *value)
1686 {
1687 DWORD RequiredSize;
1688 BOOL ret;
1689
1690 ret = SetupGetStringFieldW(
1691 context,
1692 index,
1693 NULL, 0,
1694 &RequiredSize);
1695 if (!ret)
1696 return FALSE;
1697 else if (RequiredSize == 0)
1698 {
1699 *value = NULL;
1700 return TRUE;
1701 }
1702
1703 /* We got the needed size for the buffer */
1704 *value = MyMalloc(RequiredSize * sizeof(WCHAR));
1705 if (!*value)
1706 {
1707 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1708 return FALSE;
1709 }
1710 ret = SetupGetStringFieldW(
1711 context,
1712 index,
1713 *value, RequiredSize, NULL);
1714 if (!ret)
1715 MyFree(*value);
1716
1717 return ret;
1718 }
1719
1720 static VOID FixupServiceBinaryPath(
1721 IN DWORD ServiceType,
1722 IN OUT LPWSTR *ServiceBinary)
1723 {
1724 LPWSTR Buffer;
1725 WCHAR ReactosDir[MAX_PATH];
1726 DWORD RosDirLength, ServiceLength, Win32Length;
1727
1728 GetWindowsDirectoryW(ReactosDir, MAX_PATH);
1729 RosDirLength = strlenW(ReactosDir);
1730 ServiceLength = strlenW(*ServiceBinary);
1731
1732 /* Check and fix two things:
1733 1. Get rid of C:\ReactOS and use relative
1734 path instead.
1735 2. Add %SystemRoot% for Win32 services */
1736
1737 if (ServiceLength < RosDirLength)
1738 return;
1739
1740 if (!wcsnicmp(*ServiceBinary, ReactosDir, RosDirLength))
1741 {
1742 /* Yes, the first part is the C:\ReactOS\, just skip it */
1743 MoveMemory(*ServiceBinary, *ServiceBinary + RosDirLength + 1,
1744 (ServiceLength - RosDirLength) * sizeof(WCHAR));
1745
1746 /* Handle Win32-services differently */
1747 if (ServiceType & SERVICE_WIN32)
1748 {
1749 Win32Length = (ServiceLength -
1750 RosDirLength - 1 + 13) * sizeof(WCHAR);
1751 /* -1 to not count the separator after C:\ReactOS
1752 wcslen(L"%SystemRoot%\\") = 13*sizeof(wchar_t) */
1753 Buffer = MyMalloc(Win32Length);
1754
1755 wcscpy(Buffer, L"%SystemRoot%\\");
1756 wcscat(Buffer, *ServiceBinary);
1757 MyFree(*ServiceBinary);
1758
1759 *ServiceBinary = Buffer;
1760 }
1761 }
1762 }
1763
1764 static BOOL InstallOneService(
1765 struct DeviceInfoSet *list,
1766 IN HINF hInf,
1767 IN LPCWSTR ServiceSection,
1768 IN LPCWSTR ServiceName,
1769 IN UINT ServiceFlags)
1770 {
1771 SC_HANDLE hSCManager = NULL;
1772 SC_HANDLE hService = NULL;
1773 LPDWORD GroupOrder = NULL;
1774 LPQUERY_SERVICE_CONFIGW ServiceConfig = NULL;
1775 HKEY hServicesKey, hServiceKey;
1776 LONG rc;
1777 BOOL ret = FALSE;
1778
1779 HKEY hGroupOrderListKey = NULL;
1780 LPWSTR ServiceBinary = NULL;
1781 LPWSTR LoadOrderGroup = NULL;
1782 LPWSTR DisplayName = NULL;
1783 LPWSTR Description = NULL;
1784 LPWSTR Dependencies = NULL;
1785 LPWSTR SecurityDescriptor = NULL;
1786 PSECURITY_DESCRIPTOR sd = NULL;
1787 INT ServiceType, StartType, ErrorControl;
1788 DWORD dwRegType;
1789 DWORD tagId = (DWORD)-1;
1790 BOOL useTag;
1791
1792 if (!GetIntField(hInf, ServiceSection, ServiceTypeKey, &ServiceType))
1793 goto cleanup;
1794 if (!GetIntField(hInf, ServiceSection, StartTypeKey, &StartType))
1795 goto cleanup;
1796 if (!GetIntField(hInf, ServiceSection, ErrorControlKey, &ErrorControl))
1797 goto cleanup;
1798 useTag = (ServiceType == SERVICE_BOOT_START || ServiceType == SERVICE_SYSTEM_START);
1799
1800 hSCManager = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASE, SC_MANAGER_CREATE_SERVICE);
1801 if (hSCManager == NULL)
1802 goto cleanup;
1803
1804 if (!GetLineText(hInf, ServiceSection, ServiceBinaryKey, &ServiceBinary))
1805 goto cleanup;
1806
1807 /* Adjust binary path according to the service type */
1808 FixupServiceBinaryPath(ServiceType, &ServiceBinary);
1809
1810 /* Don't check return value, as these fields are optional and
1811 * GetLineText initialize output parameter even on failure */
1812 GetLineText(hInf, ServiceSection, LoadOrderGroupKey, &LoadOrderGroup);
1813 GetLineText(hInf, ServiceSection, DisplayNameKey, &DisplayName);
1814 GetLineText(hInf, ServiceSection, DescriptionKey, &Description);
1815 GetLineText(hInf, ServiceSection, DependenciesKey, &Dependencies);
1816
1817 /* If there is no group, we must not request a tag */
1818 if (!LoadOrderGroup || !*LoadOrderGroup)
1819 useTag = FALSE;
1820
1821 hService = OpenServiceW(
1822 hSCManager,
1823 ServiceName,
1824 DELETE | SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG | WRITE_DAC);
1825 if (hService == NULL && GetLastError() != ERROR_SERVICE_DOES_NOT_EXIST)
1826 goto cleanup;
1827
1828 if (hService && (ServiceFlags & SPSVCINST_DELETEEVENTLOGENTRY))
1829 {
1830 ret = DeleteService(hService);
1831 if (!ret && GetLastError() != ERROR_SERVICE_MARKED_FOR_DELETE)
1832 goto cleanup;
1833 }
1834
1835 if (hService == NULL)
1836 {
1837 /* Create new service */
1838 hService = CreateServiceW(
1839 hSCManager,
1840 ServiceName,
1841 DisplayName,
1842 WRITE_DAC,
1843 ServiceType,
1844 StartType,
1845 ErrorControl,
1846 ServiceBinary,
1847 LoadOrderGroup,
1848 useTag ? &tagId : NULL,
1849 Dependencies,
1850 NULL, NULL);
1851 if (hService == NULL)
1852 goto cleanup;
1853 }
1854 else
1855 {
1856 DWORD bufferSize;
1857 /* Read current configuration */
1858 if (!QueryServiceConfigW(hService, NULL, 0, &bufferSize))
1859 {
1860 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
1861 goto cleanup;
1862 ServiceConfig = MyMalloc(bufferSize);
1863 if (!ServiceConfig)
1864 {
1865 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1866 goto cleanup;
1867 }
1868 if (!QueryServiceConfigW(hService, ServiceConfig, bufferSize, &bufferSize))
1869 goto cleanup;
1870 }
1871 tagId = ServiceConfig->dwTagId;
1872
1873 /* Update configuration */
1874 ret = ChangeServiceConfigW(
1875 hService,
1876 ServiceType,
1877 (ServiceFlags & SPSVCINST_NOCLOBBER_STARTTYPE) ? SERVICE_NO_CHANGE : StartType,
1878 (ServiceFlags & SPSVCINST_NOCLOBBER_ERRORCONTROL) ? SERVICE_NO_CHANGE : ErrorControl,
1879 ServiceBinary,
1880 (ServiceFlags & SPSVCINST_NOCLOBBER_LOADORDERGROUP && ServiceConfig->lpLoadOrderGroup) ? NULL : LoadOrderGroup,
1881 useTag ? &tagId : NULL,
1882 (ServiceFlags & SPSVCINST_NOCLOBBER_DEPENDENCIES && ServiceConfig->lpDependencies) ? NULL : Dependencies,
1883 NULL, NULL,
1884 (ServiceFlags & SPSVCINST_NOCLOBBER_DISPLAYNAME && ServiceConfig->lpDisplayName) ? NULL : DisplayName);
1885 if (!ret)
1886 goto cleanup;
1887 }
1888
1889 /* Set security */
1890 if (GetLineText(hInf, ServiceSection, SecurityKey, &SecurityDescriptor))
1891 {
1892 ret = ConvertStringSecurityDescriptorToSecurityDescriptorW(SecurityDescriptor, SDDL_REVISION_1, &sd, NULL);
1893 if (!ret)
1894 goto cleanup;
1895 ret = SetServiceObjectSecurity(hService, DACL_SECURITY_INFORMATION, sd);
1896 if (!ret)
1897 goto cleanup;
1898 }
1899
1900 /* FIXME: use Description and SPSVCINST_NOCLOBBER_DESCRIPTION */
1901
1902 if (useTag)
1903 {
1904 /* Add the tag to SYSTEM\CurrentControlSet\Control\GroupOrderList key */
1905 LPCWSTR lpLoadOrderGroup;
1906 DWORD bufferSize;
1907
1908 lpLoadOrderGroup = LoadOrderGroup;
1909 if ((ServiceFlags & SPSVCINST_NOCLOBBER_LOADORDERGROUP) && ServiceConfig && ServiceConfig->lpLoadOrderGroup)
1910 lpLoadOrderGroup = ServiceConfig->lpLoadOrderGroup;
1911
1912 rc = RegOpenKeyW(
1913 list ? list->HKLM : HKEY_LOCAL_MACHINE,
1914 GroupOrderListKey,
1915 &hGroupOrderListKey);
1916 if (rc != ERROR_SUCCESS)
1917 {
1918 SetLastError(rc);
1919 goto cleanup;
1920 }
1921 rc = RegQueryValueExW(hGroupOrderListKey, lpLoadOrderGroup, NULL, &dwRegType, NULL, &bufferSize);
1922 if (rc == ERROR_FILE_NOT_FOUND)
1923 bufferSize = sizeof(DWORD);
1924 else if (rc != ERROR_SUCCESS)
1925 {
1926 SetLastError(rc);
1927 goto cleanup;
1928 }
1929 else if (dwRegType != REG_BINARY || bufferSize == 0 || bufferSize % sizeof(DWORD) != 0)
1930 {
1931 SetLastError(ERROR_GEN_FAILURE);
1932 goto cleanup;
1933 }
1934 /* Allocate buffer to store existing data + the new tag */
1935 GroupOrder = MyMalloc(bufferSize + sizeof(DWORD));
1936 if (!GroupOrder)
1937 {
1938 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1939 goto cleanup;
1940 }
1941 if (rc == ERROR_SUCCESS)
1942 {
1943 /* Read existing data */
1944 rc = RegQueryValueExW(
1945 hGroupOrderListKey,
1946 lpLoadOrderGroup,
1947 NULL,
1948 NULL,
1949 (BYTE*)GroupOrder,
1950 &bufferSize);
1951 if (rc != ERROR_SUCCESS)
1952 {
1953 SetLastError(rc);
1954 goto cleanup;
1955 }
1956 if (ServiceFlags & SPSVCINST_TAGTOFRONT)
1957 memmove(&GroupOrder[2], &GroupOrder[1], bufferSize - sizeof(DWORD));
1958 }
1959 else
1960 {
1961 GroupOrder[0] = 0;
1962 }
1963 GroupOrder[0]++;
1964 if (ServiceFlags & SPSVCINST_TAGTOFRONT)
1965 GroupOrder[1] = tagId;
1966 else
1967 GroupOrder[bufferSize / sizeof(DWORD)] = tagId;
1968
1969 rc = RegSetValueExW(
1970 hGroupOrderListKey,
1971 lpLoadOrderGroup,
1972 0,
1973 REG_BINARY,
1974 (BYTE*)GroupOrder,
1975 bufferSize + sizeof(DWORD));
1976 if (rc != ERROR_SUCCESS)
1977 {
1978 SetLastError(rc);
1979 goto cleanup;
1980 }
1981 }
1982
1983 /* Handle AddReg and DelReg */
1984 rc = RegOpenKeyExW(
1985 list ? list->HKLM : HKEY_LOCAL_MACHINE,
1986 REGSTR_PATH_SERVICES,
1987 0,
1988 0,
1989 &hServicesKey);
1990 if (rc != ERROR_SUCCESS)
1991 {
1992 SetLastError(rc);
1993 goto cleanup;
1994 }
1995 rc = RegOpenKeyExW(
1996 hServicesKey,
1997 ServiceName,
1998 0,
1999 KEY_READ | KEY_WRITE,
2000 &hServiceKey);
2001 RegCloseKey(hServicesKey);
2002 if (rc != ERROR_SUCCESS)
2003 {
2004 SetLastError(rc);
2005 goto cleanup;
2006 }
2007
2008 ret = SetupInstallFromInfSectionW(
2009 NULL,
2010 hInf,
2011 ServiceSection,
2012 SPINST_REGISTRY,
2013 hServiceKey,
2014 NULL,
2015 0,
2016 NULL,
2017 NULL,
2018 NULL,
2019 NULL);
2020 RegCloseKey(hServiceKey);
2021
2022 cleanup:
2023 if (hSCManager != NULL)
2024 CloseServiceHandle(hSCManager);
2025 if (hService != NULL)
2026 CloseServiceHandle(hService);
2027 if (hGroupOrderListKey != NULL)
2028 RegCloseKey(hGroupOrderListKey);
2029 if (sd != NULL)
2030 LocalFree(sd);
2031 MyFree(ServiceConfig);
2032 MyFree(ServiceBinary);
2033 MyFree(LoadOrderGroup);
2034 MyFree(DisplayName);
2035 MyFree(Description);
2036 MyFree(Dependencies);
2037 MyFree(SecurityDescriptor);
2038 MyFree(GroupOrder);
2039
2040 TRACE("Returning %d\n", ret);
2041 return ret;
2042 }
2043
2044
2045 /***********************************************************************
2046 * SetupInstallServicesFromInfSectionExW (SETUPAPI.@)
2047 */
2048 BOOL WINAPI SetupInstallServicesFromInfSectionExW( HINF hinf, PCWSTR sectionname, DWORD flags, HDEVINFO DeviceInfoSet, PSP_DEVINFO_DATA DeviceInfoData, PVOID reserved1, PVOID reserved2 )
2049 {
2050 struct DeviceInfoSet *list = NULL;
2051 BOOL ret = FALSE;
2052
2053 TRACE("%p, %s, 0x%lx, %p, %p, %p, %p\n", hinf, debugstr_w(sectionname),
2054 flags, DeviceInfoSet, DeviceInfoData, reserved1, reserved2);
2055
2056 if (!sectionname)
2057 SetLastError(ERROR_INVALID_PARAMETER);
2058 else if (flags & ~(SPSVCINST_TAGTOFRONT | SPSVCINST_DELETEEVENTLOGENTRY | SPSVCINST_NOCLOBBER_DISPLAYNAME | SPSVCINST_NOCLOBBER_STARTTYPE | SPSVCINST_NOCLOBBER_ERRORCONTROL | SPSVCINST_NOCLOBBER_LOADORDERGROUP | SPSVCINST_NOCLOBBER_DEPENDENCIES | SPSVCINST_STOPSERVICE))
2059 {
2060 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));
2061 SetLastError(ERROR_INVALID_FLAGS);
2062 }
2063 else if (DeviceInfoSet == (HDEVINFO)INVALID_HANDLE_VALUE)
2064 SetLastError(ERROR_INVALID_HANDLE);
2065 else if (DeviceInfoSet && (list = (struct DeviceInfoSet *)DeviceInfoSet)->magic != SETUP_DEVICE_INFO_SET_MAGIC)
2066 SetLastError(ERROR_INVALID_HANDLE);
2067 else if (DeviceInfoData && DeviceInfoData->cbSize != sizeof(SP_DEVINFO_DATA))
2068 SetLastError(ERROR_INVALID_USER_BUFFER);
2069 else if (reserved1 != NULL || reserved2 != NULL)
2070 SetLastError(ERROR_INVALID_PARAMETER);
2071 else
2072 {
2073 struct needs_callback_info needs_info;
2074 LPWSTR ServiceName = NULL;
2075 LPWSTR ServiceSection = NULL;
2076 INT ServiceFlags;
2077 INFCONTEXT ContextService;
2078 BOOL bNeedReboot = FALSE;
2079
2080 /* Parse 'Include' and 'Needs' directives */
2081 iterate_section_fields( hinf, sectionname, Include, include_callback, NULL);
2082 needs_info.type = 1;
2083 needs_info.flags = flags;
2084 needs_info.devinfo = DeviceInfoSet;
2085 needs_info.devinfo_data = DeviceInfoData;
2086 needs_info.reserved1 = reserved1;
2087 needs_info.reserved2 = reserved2;
2088 iterate_section_fields( hinf, sectionname, Needs, needs_callback, &needs_info);
2089
2090 if (flags & SPSVCINST_STOPSERVICE)
2091 {
2092 FIXME("Stopping the device not implemented\n");
2093 /* This may lead to require a reboot */
2094 /* bNeedReboot = TRUE; */
2095 #if 0
2096 SERVICE_STATUS ServiceStatus;
2097 ret = ControlService(hService, SERVICE_CONTROL_STOP, &ServiceStatus);
2098 if (!ret && GetLastError() != ERROR_SERVICE_NOT_ACTIVE)
2099 goto cleanup;
2100 if (ServiceStatus.dwCurrentState != SERVICE_STOP_PENDING && ServiceStatus.dwCurrentState != SERVICE_STOPPED)
2101 {
2102 SetLastError(ERROR_INSTALL_SERVICE_FAILURE);
2103 goto cleanup;
2104 }
2105 #endif
2106 flags &= ~SPSVCINST_STOPSERVICE;
2107 }
2108
2109 ret = SetupFindFirstLineW(hinf, sectionname, AddService, &ContextService);
2110 while (ret)
2111 {
2112 if (!GetStringField(&ContextService, 1, &ServiceName))
2113 goto nextservice;
2114
2115 ret = SetupGetIntField(
2116 &ContextService,
2117 2, /* Field index */
2118 &ServiceFlags);
2119 if (!ret)
2120 {
2121 /* The field may be empty. Ignore the error */
2122 ServiceFlags = 0;
2123 }
2124
2125 if (!GetStringField(&ContextService, 3, &ServiceSection))
2126 goto nextservice;
2127
2128 ret = InstallOneService(list, hinf, ServiceSection, ServiceName, (ServiceFlags & ~SPSVCINST_ASSOCSERVICE) | flags);
2129 if (!ret)
2130 goto nextservice;
2131
2132 if (ServiceFlags & SPSVCINST_ASSOCSERVICE)
2133 {
2134 ret = SetupDiSetDeviceRegistryPropertyW(DeviceInfoSet, DeviceInfoData, SPDRP_SERVICE, (LPBYTE)ServiceName, (strlenW(ServiceName) + 1) * sizeof(WCHAR));
2135 if (!ret)
2136 goto nextservice;
2137 }
2138
2139 nextservice:
2140 HeapFree(GetProcessHeap(), 0, ServiceName);
2141 HeapFree(GetProcessHeap(), 0, ServiceSection);
2142 ServiceName = ServiceSection = NULL;
2143 ret = SetupFindNextMatchLineW(&ContextService, AddService, &ContextService);
2144 }
2145
2146 if (bNeedReboot)
2147 SetLastError(ERROR_SUCCESS_REBOOT_REQUIRED);
2148 else
2149 SetLastError(ERROR_SUCCESS);
2150 ret = TRUE;
2151 }
2152
2153 TRACE("Returning %d\n", ret);
2154 return ret;
2155 }
2156
2157
2158 /***********************************************************************
2159 * SetupCopyOEMInfA (SETUPAPI.@)
2160 */
2161 BOOL WINAPI SetupCopyOEMInfA(
2162 IN PCSTR SourceInfFileName,
2163 IN PCSTR OEMSourceMediaLocation,
2164 IN DWORD OEMSourceMediaType,
2165 IN DWORD CopyStyle,
2166 OUT PSTR DestinationInfFileName OPTIONAL,
2167 IN DWORD DestinationInfFileNameSize,
2168 OUT PDWORD RequiredSize OPTIONAL,
2169 OUT PSTR* DestinationInfFileNameComponent OPTIONAL)
2170 {
2171 PWSTR SourceInfFileNameW = NULL;
2172 PWSTR OEMSourceMediaLocationW = NULL;
2173 PWSTR DestinationInfFileNameW = NULL;
2174 PWSTR DestinationInfFileNameComponentW = NULL;
2175 BOOL ret = FALSE;
2176
2177 TRACE("%s %s 0x%lx 0x%lx %p 0%lu %p %p\n",
2178 SourceInfFileName, OEMSourceMediaLocation, OEMSourceMediaType,
2179 CopyStyle, DestinationInfFileName, DestinationInfFileNameSize,
2180 RequiredSize, DestinationInfFileNameComponent);
2181
2182 if (!DestinationInfFileName && DestinationInfFileNameSize > 0)
2183 SetLastError(ERROR_INVALID_PARAMETER);
2184 else if (!(SourceInfFileNameW = pSetupMultiByteToUnicode(SourceInfFileName, CP_ACP)))
2185 SetLastError(ERROR_INVALID_PARAMETER);
2186 else if (OEMSourceMediaType != SPOST_NONE && !(OEMSourceMediaLocationW = pSetupMultiByteToUnicode(OEMSourceMediaLocation, CP_ACP)))
2187 SetLastError(ERROR_INVALID_PARAMETER);
2188 else
2189 {
2190 if (DestinationInfFileNameSize != 0)
2191 {
2192 DestinationInfFileNameW = MyMalloc(DestinationInfFileNameSize * sizeof(WCHAR));
2193 if (!DestinationInfFileNameW)
2194 {
2195 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2196 goto cleanup;
2197 }
2198 }
2199
2200 ret = SetupCopyOEMInfW(
2201 SourceInfFileNameW,
2202 OEMSourceMediaLocationW,
2203 OEMSourceMediaType,
2204 CopyStyle,
2205 DestinationInfFileNameW,
2206 DestinationInfFileNameSize,
2207 RequiredSize,
2208 DestinationInfFileNameComponent ? &DestinationInfFileNameComponentW : NULL);
2209 if (!ret)
2210 goto cleanup;
2211
2212 if (DestinationInfFileNameSize != 0)
2213 {
2214 if (WideCharToMultiByte(CP_ACP, 0, DestinationInfFileNameW, -1,
2215 DestinationInfFileName, DestinationInfFileNameSize, NULL, NULL) == 0)
2216 {
2217 DestinationInfFileName[0] = '\0';
2218 goto cleanup;
2219 }
2220 }
2221 if (DestinationInfFileNameComponent)
2222 {
2223 if (DestinationInfFileNameComponentW)
2224 *DestinationInfFileNameComponent = &DestinationInfFileName[DestinationInfFileNameComponentW - DestinationInfFileNameW];
2225 else
2226 *DestinationInfFileNameComponent = NULL;
2227 }
2228 ret = TRUE;
2229 }
2230
2231 cleanup:
2232 MyFree(SourceInfFileNameW);
2233 MyFree(OEMSourceMediaLocationW);
2234 MyFree(DestinationInfFileNameW);
2235 TRACE("Returning %d\n", ret);
2236 if (ret) SetLastError(ERROR_SUCCESS);
2237 return ret;
2238 }
2239
2240 static int compare_files( HANDLE file1, HANDLE file2 )
2241 {
2242 char buffer1[2048];
2243 char buffer2[2048];
2244 DWORD size1;
2245 DWORD size2;
2246
2247 while( ReadFile(file1, buffer1, sizeof(buffer1), &size1, NULL) &&
2248 ReadFile(file2, buffer2, sizeof(buffer2), &size2, NULL) )
2249 {
2250 int ret;
2251 if (size1 != size2)
2252 return size1 > size2 ? 1 : -1;
2253 if (!size1)
2254 return 0;
2255 ret = memcmp( buffer1, buffer2, size1 );
2256 if (ret)
2257 return ret;
2258 }
2259
2260 return 0;
2261 }
2262
2263 /***********************************************************************
2264 * SetupCopyOEMInfW (SETUPAPI.@)
2265 */
2266 BOOL WINAPI SetupCopyOEMInfW(
2267 IN PCWSTR SourceInfFileName,
2268 IN PCWSTR OEMSourceMediaLocation,
2269 IN DWORD OEMSourceMediaType,
2270 IN DWORD CopyStyle,
2271 OUT PWSTR DestinationInfFileName OPTIONAL,
2272 IN DWORD DestinationInfFileNameSize,
2273 OUT PDWORD RequiredSize OPTIONAL,
2274 OUT PWSTR* DestinationInfFileNameComponent OPTIONAL)
2275 {
2276 BOOL ret = FALSE;
2277
2278 TRACE("%s %s 0x%lx 0x%lx %p 0%lu %p %p\n",
2279 debugstr_w(SourceInfFileName), debugstr_w(OEMSourceMediaLocation), OEMSourceMediaType,
2280 CopyStyle, DestinationInfFileName, DestinationInfFileNameSize,
2281 RequiredSize, DestinationInfFileNameComponent);
2282
2283 if (!SourceInfFileName)
2284 SetLastError(ERROR_INVALID_PARAMETER);
2285 else if (OEMSourceMediaType != SPOST_NONE && OEMSourceMediaType != SPOST_PATH && OEMSourceMediaType != SPOST_URL)
2286 SetLastError(ERROR_INVALID_PARAMETER);
2287 else if (OEMSourceMediaType != SPOST_NONE && !OEMSourceMediaLocation)
2288 SetLastError(ERROR_INVALID_PARAMETER);
2289 else if (CopyStyle & ~(SP_COPY_DELETESOURCE | SP_COPY_REPLACEONLY | SP_COPY_NOOVERWRITE | SP_COPY_OEMINF_CATALOG_ONLY))
2290 {
2291 TRACE("Unknown flags: 0x%08lx\n", CopyStyle & ~(SP_COPY_DELETESOURCE | SP_COPY_REPLACEONLY | SP_COPY_NOOVERWRITE | SP_COPY_OEMINF_CATALOG_ONLY));
2292 SetLastError(ERROR_INVALID_FLAGS);
2293 }
2294 else if (!DestinationInfFileName && DestinationInfFileNameSize > 0)
2295 SetLastError(ERROR_INVALID_PARAMETER);
2296 else if (CopyStyle & SP_COPY_OEMINF_CATALOG_ONLY)
2297 {
2298 FIXME("CopyStyle 0x%x not supported\n", SP_COPY_OEMINF_CATALOG_ONLY);
2299 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2300 }
2301 else
2302 {
2303 HANDLE hSearch = INVALID_HANDLE_VALUE;
2304 WIN32_FIND_DATAW FindFileData;
2305 BOOL AlreadyExists;
2306 DWORD NextFreeNumber = 0;
2307 SIZE_T len;
2308 LPWSTR pFullFileName = NULL;
2309 LPWSTR pFileName; /* Pointer into pFullFileName buffer */
2310 HANDLE hSourceFile = INVALID_HANDLE_VALUE;
2311
2312 if (OEMSourceMediaType == SPOST_PATH || OEMSourceMediaType == SPOST_URL)
2313 FIXME("OEMSourceMediaType 0x%lx ignored\n", OEMSourceMediaType);
2314
2315 /* Check if source file exists, and open it */
2316 if (strchrW(SourceInfFileName, '\\' ) || strchrW(SourceInfFileName, '/' ))
2317 {
2318 WCHAR *path;
2319
2320 if (!(len = GetFullPathNameW(SourceInfFileName, 0, NULL, NULL)))
2321 return FALSE;
2322 if (!(path = MyMalloc(len * sizeof(WCHAR))))
2323 {
2324 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2325 return FALSE;
2326 }
2327 GetFullPathNameW(SourceInfFileName, len, path, NULL);
2328 hSourceFile = CreateFileW(
2329 path, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
2330 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
2331 NULL, OPEN_EXISTING, 0, NULL);
2332 MyFree(path);
2333 }
2334 else /* try Windows directory */
2335 {
2336 WCHAR *path, *p;
2337 static const WCHAR Inf[] = {'\\','i','n','f','\\',0};
2338 static const WCHAR System32[] = {'\\','s','y','s','t','e','m','3','2','\\',0};
2339
2340 len = GetWindowsDirectoryW(NULL, 0) + strlenW(SourceInfFileName) + 12;
2341 if (!(path = MyMalloc(len * sizeof(WCHAR))))
2342 {
2343 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2344 return FALSE;
2345 }
2346 GetWindowsDirectoryW(path, len);
2347 p = path + strlenW(path);
2348 strcpyW(p, Inf);
2349 strcatW(p, SourceInfFileName);
2350 hSourceFile = CreateFileW(
2351 path, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
2352 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
2353 NULL, OPEN_EXISTING, 0, NULL);
2354 if (hSourceFile == INVALID_HANDLE_VALUE)
2355 {
2356 strcpyW(p, System32);
2357 strcatW(p, SourceInfFileName);
2358 hSourceFile = CreateFileW(
2359 path, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
2360 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
2361 NULL, OPEN_EXISTING, 0, NULL);
2362 }
2363 MyFree(path);
2364 }
2365 if (hSourceFile == INVALID_HANDLE_VALUE)
2366 {
2367 SetLastError(ERROR_FILE_NOT_FOUND);
2368 goto cleanup;
2369 }
2370
2371 /* Prepare .inf file specification */
2372 len = MAX_PATH + 1 + strlenW(InfDirectory) + 13;
2373 pFullFileName = MyMalloc(len * sizeof(WCHAR));
2374 if (!pFullFileName)
2375 {
2376 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
2377 goto cleanup;
2378 }
2379 len = GetSystemWindowsDirectoryW(pFullFileName, MAX_PATH);
2380 if (len == 0 || len > MAX_PATH)
2381 goto cleanup;
2382 if (pFullFileName[strlenW(pFullFileName) - 1] != '\\')
2383 strcatW(pFullFileName, BackSlash);
2384 strcatW(pFullFileName, InfDirectory);
2385 pFileName = &pFullFileName[strlenW(pFullFileName)];
2386
2387 /* Search if the specified .inf file already exists in %WINDIR%\Inf */
2388 AlreadyExists = FALSE;
2389 strcpyW(pFileName, OemFileMask);
2390 hSearch = FindFirstFileW(pFullFileName, &FindFileData);
2391 if (hSearch != INVALID_HANDLE_VALUE)
2392 {
2393 LARGE_INTEGER SourceFileSize;
2394
2395 if (GetFileSizeEx(hSourceFile, &SourceFileSize))
2396 {
2397 do
2398 {
2399 LARGE_INTEGER DestFileSize;
2400 HANDLE hDestFile;
2401
2402 strcpyW(pFileName, FindFileData.cFileName);
2403 hDestFile = CreateFileW(
2404 pFullFileName, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
2405 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
2406 NULL, OPEN_EXISTING, 0, NULL);
2407 if (hDestFile != INVALID_HANDLE_VALUE)
2408 {
2409 if (GetFileSizeEx(hDestFile, &DestFileSize)
2410 && DestFileSize.QuadPart == SourceFileSize.QuadPart
2411 && !compare_files(hSourceFile, hDestFile))
2412 {
2413 TRACE("%s already exists as %s\n",
2414 debugstr_w(SourceInfFileName), debugstr_w(pFileName));
2415 AlreadyExists = TRUE;
2416 }
2417 }
2418 } while (!AlreadyExists && FindNextFileW(hSearch, &FindFileData));
2419 }
2420 FindClose(hSearch);
2421 hSearch = INVALID_HANDLE_VALUE;
2422 }
2423
2424 if (!AlreadyExists && CopyStyle & SP_COPY_REPLACEONLY)
2425 {
2426 /* FIXME: set DestinationInfFileName, RequiredSize, DestinationInfFileNameComponent */
2427 SetLastError(ERROR_FILE_NOT_FOUND);
2428 goto cleanup;
2429 }
2430 else if (AlreadyExists && (CopyStyle & SP_COPY_NOOVERWRITE))
2431 {
2432 DWORD Size = strlenW(pFileName) + 1;
2433
2434 if (RequiredSize)
2435 *RequiredSize = Size;
2436 if (DestinationInfFileNameSize == 0)
2437 SetLastError(ERROR_FILE_EXISTS);
2438 else if (DestinationInfFileNameSize < Size)
2439 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2440 else
2441 {
2442 SetLastError(ERROR_FILE_EXISTS);
2443 strcpyW(DestinationInfFileName, pFileName);
2444 }
2445 goto cleanup;
2446 }
2447
2448 /* Search the number to give to OEM??.INF */
2449 strcpyW(pFileName, OemFileMask);
2450 hSearch = FindFirstFileW(pFullFileName, &FindFileData);
2451 if (hSearch == INVALID_HANDLE_VALUE)
2452 {
2453 if (GetLastError() != ERROR_FILE_NOT_FOUND)
2454 goto cleanup;
2455 }
2456 else
2457 {
2458 do
2459 {
2460 DWORD CurrentNumber;
2461 if (swscanf(FindFileData.cFileName, OemFileSpecification, &CurrentNumber) == 1
2462 && CurrentNumber <= 99999)
2463 {
2464 if (CurrentNumber >= NextFreeNumber)
2465 NextFreeNumber = CurrentNumber + 1;
2466 }
2467 } while (FindNextFileW(hSearch, &FindFileData));
2468 }
2469
2470 if (NextFreeNumber > 99999)
2471 {
2472 ERR("Too much custom .inf files\n");
2473 SetLastError(ERROR_GEN_FAILURE);
2474 goto cleanup;
2475 }
2476
2477 /* Create the full path: %WINDIR%\Inf\OEM{XXXXX}.inf */
2478 sprintfW(pFileName, OemFileSpecification, NextFreeNumber);
2479 TRACE("Next available file is %s\n", debugstr_w(pFileName));
2480
2481 if (!CopyFileW(SourceInfFileName, pFullFileName, TRUE))
2482 {
2483 TRACE("CopyFileW() failed with error 0x%lx\n", GetLastError());
2484 goto cleanup;
2485 }
2486
2487 len = strlenW(pFullFileName) + 1;
2488 if (RequiredSize)
2489 *RequiredSize = len;
2490 if (DestinationInfFileName)
2491 {
2492 if (DestinationInfFileNameSize >= len)
2493 {
2494 strcpyW(DestinationInfFileName, pFullFileName);
2495 if (DestinationInfFileNameComponent)
2496 *DestinationInfFileNameComponent = &DestinationInfFileName[pFileName - pFullFileName];
2497 }
2498 else
2499 {
2500 SetLastError(ERROR_INSUFFICIENT_BUFFER);
2501 goto cleanup;
2502 }
2503 }
2504
2505 if (CopyStyle & SP_COPY_DELETESOURCE)
2506 {
2507 if (!DeleteFileW(SourceInfFileName))
2508 {
2509 TRACE("DeleteFileW() failed with error 0x%lx\n", GetLastError());
2510 goto cleanup;
2511 }
2512 }
2513
2514 ret = TRUE;
2515
2516 cleanup:
2517 if (hSourceFile != INVALID_HANDLE_VALUE)
2518 CloseHandle(hSourceFile);
2519 if (hSearch != INVALID_HANDLE_VALUE)
2520 FindClose(hSearch);
2521 MyFree(pFullFileName);
2522 }
2523
2524 TRACE("Returning %d\n", ret);
2525 if (ret) SetLastError(ERROR_SUCCESS);
2526 return ret;
2527 }