source: branches/gcc-kmk/src/setupapi/install.c@ 21801

Last change on this file since 21801 was 9403, checked in by sandervl, 23 years ago

Wine resync
File size: 22.5 KB
Line 
1/*
2 * Setupapi install routines
3 *
4 * Copyright 2002 Alexandre Julliard for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21#include "windef.h"
22#include "winbase.h"
23#include "winternl.h"
24#include "winerror.h"
25#include "setupapi.h"
26#include "wine/unicode.h"
27#include "setupapi_private.h"
28#include "wine/debug.h"
29
30WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
31
32/* info passed to callback functions dealing with files */
33struct files_callback_info
34{
35 HSPFILEQ queue;
36 PCWSTR src_root;
37 UINT copy_flags;
38 HINF layout;
39};
40
41/* info passed to callback functions dealing with the registry */
42struct registry_callback_info
43{
44 HKEY default_root;
45 BOOL delete;
46};
47
48typedef BOOL (*iterate_fields_func)( HINF hinf, PCWSTR field, void *arg );
49
50/* Unicode constants */
51static const WCHAR CopyFiles[] = {'C','o','p','y','F','i','l','e','s',0};
52static const WCHAR DelFiles[] = {'D','e','l','F','i','l','e','s',0};
53static const WCHAR RenFiles[] = {'R','e','n','F','i','l','e','s',0};
54static const WCHAR Ini2Reg[] = {'I','n','i','2','R','e','g',0};
55static const WCHAR LogConf[] = {'L','o','g','C','o','n','f',0};
56static const WCHAR AddReg[] = {'A','d','d','R','e','g',0};
57static const WCHAR DelReg[] = {'D','e','l','R','e','g',0};
58static const WCHAR UpdateInis[] = {'U','p','d','a','t','e','I','n','i','s',0};
59static const WCHAR UpdateIniFields[] = {'U','p','d','a','t','e','I','n','i','F','i','e','l','d','s',0};
60
61
62/***********************************************************************
63 * get_field_string
64 *
65 * Retrieve the contents of a field, dynamically growing the buffer if necessary.
66 */
67static WCHAR *get_field_string( INFCONTEXT *context, DWORD index, WCHAR *buffer,
68 WCHAR *static_buffer, DWORD *size )
69{
70 DWORD required;
71
72 if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
73 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
74 {
75 /* now grow the buffer */
76 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
77 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, required*sizeof(WCHAR) ))) return NULL;
78 *size = required;
79 if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
80 }
81 if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
82 return NULL;
83}
84
85
86/***********************************************************************
87 * copy_files_callback
88 *
89 * Called once for each CopyFiles entry in a given section.
90 */
91static BOOL copy_files_callback( HINF hinf, PCWSTR field, void *arg )
92{
93 struct files_callback_info *info = arg;
94
95 if (field[0] == '@') /* special case: copy single file */
96 SetupQueueDefaultCopyW( info->queue, info->layout, info->src_root, NULL, field, info->copy_flags );
97 else
98 SetupQueueCopySectionW( info->queue, info->src_root, info->layout, hinf, field, info->copy_flags );
99 return TRUE;
100}
101
102
103/***********************************************************************
104 * delete_files_callback
105 *
106 * Called once for each DelFiles entry in a given section.
107 */
108static BOOL delete_files_callback( HINF hinf, PCWSTR field, void *arg )
109{
110 struct files_callback_info *info = arg;
111 SetupQueueDeleteSectionW( info->queue, hinf, 0, field );
112 return TRUE;
113}
114
115
116/***********************************************************************
117 * rename_files_callback
118 *
119 * Called once for each RenFiles entry in a given section.
120 */
121static BOOL rename_files_callback( HINF hinf, PCWSTR field, void *arg )
122{
123 struct files_callback_info *info = arg;
124 SetupQueueRenameSectionW( info->queue, hinf, 0, field );
125 return TRUE;
126}
127
128
129/***********************************************************************
130 * get_root_key
131 *
132 * Retrieve the registry root key from its name.
133 */
134static HKEY get_root_key( const WCHAR *name, HKEY def_root )
135{
136 static const WCHAR HKCR[] = {'H','K','C','R',0};
137 static const WCHAR HKCU[] = {'H','K','C','U',0};
138 static const WCHAR HKLM[] = {'H','K','L','M',0};
139 static const WCHAR HKU[] = {'H','K','U',0};
140 static const WCHAR HKR[] = {'H','K','R',0};
141
142 if (!strcmpiW( name, HKCR )) return HKEY_CLASSES_ROOT;
143 if (!strcmpiW( name, HKCU )) return HKEY_CURRENT_USER;
144 if (!strcmpiW( name, HKLM )) return HKEY_LOCAL_MACHINE;
145 if (!strcmpiW( name, HKU )) return HKEY_USERS;
146 if (!strcmpiW( name, HKR )) return def_root;
147 return 0;
148}
149
150
151/***********************************************************************
152 * append_multi_sz_value
153 *
154 * Append a multisz string to a multisz registry value.
155 */
156static void append_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *strings,
157 DWORD str_size )
158{
159 DWORD size, type, total;
160 WCHAR *buffer, *p;
161
162 if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
163 if (type != REG_MULTI_SZ) return;
164
165 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (size + str_size) * sizeof(WCHAR) ))) return;
166 if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
167
168 /* compare each string against all the existing ones */
169 total = size;
170 while (*strings)
171 {
172 int len = strlenW(strings) + 1;
173
174 for (p = buffer; *p; p += strlenW(p) + 1)
175 if (!strcmpiW( p, strings )) break;
176
177 if (!*p) /* not found, need to append it */
178 {
179 memcpy( p, strings, len * sizeof(WCHAR) );
180 p[len] = 0;
181 total += len;
182 }
183 strings += len;
184 }
185 if (total != size)
186 {
187 TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer) );
188 RegSetValueExW( hkey, value, 0, REG_MULTI_SZ, (BYTE *)buffer, total );
189 }
190 done:
191 HeapFree( GetProcessHeap(), 0, buffer );
192}
193
194
195/***********************************************************************
196 * delete_multi_sz_value
197 *
198 * Remove a string from a multisz registry value.
199 */
200static void delete_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *string )
201{
202 DWORD size, type;
203 WCHAR *buffer, *src, *dst;
204
205 if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
206 if (type != REG_MULTI_SZ) return;
207 /* allocate double the size, one for value before and one for after */
208 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size * 2 * sizeof(WCHAR) ))) return;
209 if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
210 src = buffer;
211 dst = buffer + size;
212 while (*src)
213 {
214 int len = strlenW(src) + 1;
215 if (strcmpiW( src, string ))
216 {
217 memcpy( dst, src, len * sizeof(WCHAR) );
218 dst += len;
219 }
220 src += len;
221 }
222 *dst++ = 0;
223 if (dst != buffer + 2*size) /* did we remove something? */
224 {
225 TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer + size) );
226 RegSetValueExW( hkey, value, 0, REG_MULTI_SZ,
227 (BYTE *)(buffer + size), dst - (buffer + size) );
228 }
229 done:
230 HeapFree( GetProcessHeap(), 0, buffer );
231}
232
233
234/***********************************************************************
235 * do_reg_operation
236 *
237 * Perform an add/delete registry operation depending on the flags.
238 */
239static BOOL do_reg_operation( HKEY hkey, const WCHAR *value, INFCONTEXT *context, INT flags )
240{
241 DWORD type, size;
242
243 if (flags & (FLG_ADDREG_DELREG_BIT | FLG_ADDREG_DELVAL)) /* deletion */
244 {
245 if (*value && !(flags & FLG_DELREG_KEYONLY_COMMON))
246 {
247 if ((flags & FLG_DELREG_MULTI_SZ_DELSTRING) == FLG_DELREG_MULTI_SZ_DELSTRING)
248 {
249 WCHAR *str;
250
251 if (!SetupGetStringFieldW( context, 5, NULL, 0, &size ) || !size) return TRUE;
252 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
253 SetupGetStringFieldW( context, 5, str, size, NULL );
254 delete_multi_sz_value( hkey, value, str );
255 HeapFree( GetProcessHeap(), 0, str );
256 }
257 else RegDeleteValueW( hkey, value );
258 }
259 else RegDeleteKeyW( hkey, NULL );
260 return TRUE;
261 }
262
263 if (flags & (FLG_ADDREG_KEYONLY|FLG_ADDREG_KEYONLY_COMMON)) return TRUE;
264
265 if (flags & (FLG_ADDREG_NOCLOBBER|FLG_ADDREG_OVERWRITEONLY))
266 {
267 BOOL exists = !RegQueryValueExW( hkey, value, NULL, NULL, NULL, NULL );
268 if (exists && (flags & FLG_ADDREG_NOCLOBBER)) return TRUE;
269 if (!exists & (flags & FLG_ADDREG_OVERWRITEONLY)) return TRUE;
270 }
271
272 switch(flags & FLG_ADDREG_TYPE_MASK)
273 {
274 case FLG_ADDREG_TYPE_SZ: type = REG_SZ; break;
275 case FLG_ADDREG_TYPE_MULTI_SZ: type = REG_MULTI_SZ; break;
276 case FLG_ADDREG_TYPE_EXPAND_SZ: type = REG_EXPAND_SZ; break;
277 case FLG_ADDREG_TYPE_BINARY: type = REG_BINARY; break;
278 case FLG_ADDREG_TYPE_DWORD: type = REG_DWORD; break;
279 case FLG_ADDREG_TYPE_NONE: type = REG_NONE; break;
280 default: type = flags >> 16; break;
281 }
282
283 if (!(flags & FLG_ADDREG_BINVALUETYPE) ||
284 (type == REG_DWORD && SetupGetFieldCount(context) == 5))
285 {
286 static const WCHAR empty;
287 WCHAR *str = NULL;
288
289 if (type == REG_MULTI_SZ)
290 {
291 if (!SetupGetMultiSzFieldW( context, 5, NULL, 0, &size )) size = 0;
292 if (size)
293 {
294 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
295 SetupGetMultiSzFieldW( context, 5, str, size, NULL );
296 }
297 if (flags & FLG_ADDREG_APPEND)
298 {
299 if (!str) return TRUE;
300 append_multi_sz_value( hkey, value, str, size );
301 HeapFree( GetProcessHeap(), 0, str );
302 return TRUE;
303 }
304 /* else fall through to normal string handling */
305 }
306 else
307 {
308 if (!SetupGetStringFieldW( context, 5, NULL, 0, &size )) size = 0;
309 if (size)
310 {
311 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
312 SetupGetStringFieldW( context, 5, str, size, NULL );
313 }
314 }
315
316 if (type == REG_DWORD)
317 {
318 DWORD dw = str ? strtolW( str, NULL, 16 ) : 0;
319 TRACE( "setting dword %s to %lx\n", debugstr_w(value), dw );
320 RegSetValueExW( hkey, value, 0, type, (BYTE *)&dw, sizeof(dw) );
321 }
322 else
323 {
324 TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(str) );
325 if (str) RegSetValueExW( hkey, value, 0, type, (BYTE *)str, size * sizeof(WCHAR) );
326 else RegSetValueExW( hkey, value, 0, type, (BYTE *)&empty, sizeof(WCHAR) );
327 }
328 HeapFree( GetProcessHeap(), 0, str );
329 return TRUE;
330 }
331 else /* get the binary data */
332 {
333 BYTE *data = NULL;
334
335 if (!SetupGetBinaryField( context, 5, NULL, 0, &size )) size = 0;
336 if (size)
337 {
338 if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
339 TRACE( "setting binary data %s len %ld\n", debugstr_w(value), size );
340 SetupGetBinaryField( context, 5, data, size, NULL );
341 }
342 RegSetValueExW( hkey, value, 0, type, data, size );
343 HeapFree( GetProcessHeap(), 0, data );
344 return TRUE;
345 }
346}
347
348
349/***********************************************************************
350 * registry_callback
351 *
352 * Called once for each AddReg and DelReg entry in a given section.
353 */
354static BOOL registry_callback( HINF hinf, PCWSTR field, void *arg )
355{
356 struct registry_callback_info *info = arg;
357 INFCONTEXT context;
358 HKEY root_key, hkey;
359
360 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
361
362 for (; ok; ok = SetupFindNextLine( &context, &context ))
363 {
364 WCHAR buffer[MAX_INF_STRING_LENGTH];
365 INT flags;
366
367 /* get root */
368 if (!SetupGetStringFieldW( &context, 1, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
369 continue;
370 if (!(root_key = get_root_key( buffer, info->default_root )))
371 continue;
372
373 /* get key */
374 if (!SetupGetStringFieldW( &context, 2, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
375 *buffer = 0;
376
377 /* get flags */
378 if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
379
380 if (!info->delete)
381 {
382 if (flags & FLG_ADDREG_DELREG_BIT) continue; /* ignore this entry */
383 }
384 else
385 {
386 if (!flags) flags = FLG_ADDREG_DELREG_BIT;
387 else if (!(flags & FLG_ADDREG_DELREG_BIT)) continue; /* ignore this entry */
388 }
389
390 if (info->delete || (flags & FLG_ADDREG_OVERWRITEONLY))
391 {
392 if (RegOpenKeyW( root_key, buffer, &hkey )) continue; /* ignore if it doesn't exist */
393 }
394 else if (RegCreateKeyW( root_key, buffer, &hkey ))
395 {
396 ERR( "could not create key %p %s\n", root_key, debugstr_w(buffer) );
397 continue;
398 }
399 TRACE( "key %p %s\n", root_key, debugstr_w(buffer) );
400
401 /* get value name */
402 if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
403 *buffer = 0;
404
405 /* and now do it */
406 if (!do_reg_operation( hkey, buffer, &context, flags ))
407 {
408 RegCloseKey( hkey );
409 return FALSE;
410 }
411 RegCloseKey( hkey );
412 }
413 return TRUE;
414}
415
416
417static BOOL update_ini_callback( HINF hinf, PCWSTR field, void *arg )
418{
419 INFCONTEXT context;
420
421 BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
422
423 for (; ok; ok = SetupFindNextLine( &context, &context ))
424 {
425 WCHAR buffer[MAX_INF_STRING_LENGTH];
426 WCHAR filename[MAX_INF_STRING_LENGTH];
427 WCHAR section[MAX_INF_STRING_LENGTH];
428 WCHAR entry[MAX_INF_STRING_LENGTH];
429 WCHAR string[MAX_INF_STRING_LENGTH];
430 LPWSTR divider;
431
432 if (!SetupGetStringFieldW( &context, 1, filename,
433 sizeof(filename)/sizeof(WCHAR), NULL ))
434 continue;
435
436 if (!SetupGetStringFieldW( &context, 2, section,
437 sizeof(section)/sizeof(WCHAR), NULL ))
438 continue;
439
440 if (!SetupGetStringFieldW( &context, 4, buffer,
441 sizeof(buffer)/sizeof(WCHAR), NULL ))
442 continue;
443
444 divider = strchrW(buffer,'=');
445 if (divider)
446 {
447 *divider = 0;
448 strcpyW(entry,buffer);
449 divider++;
450 strcpyW(string,divider);
451 }
452 else
453 {
454 strcpyW(entry,buffer);
455 string[0]=0;
456 }
457
458 TRACE("Writing %s = %s in %s of file %s\n",debugstr_w(entry),
459 debugstr_w(string),debugstr_w(section),debugstr_w(filename));
460 WritePrivateProfileStringW(section,entry,string,filename);
461
462 }
463 return TRUE;
464}
465
466static BOOL update_ini_fields_callback( HINF hinf, PCWSTR field, void *arg )
467{
468 FIXME( "should update ini fields %s\n", debugstr_w(field) );
469 return TRUE;
470}
471
472static BOOL ini2reg_callback( HINF hinf, PCWSTR field, void *arg )
473{
474 FIXME( "should do ini2reg %s\n", debugstr_w(field) );
475 return TRUE;
476}
477
478static BOOL logconf_callback( HINF hinf, PCWSTR field, void *arg )
479{
480 FIXME( "should do logconf %s\n", debugstr_w(field) );
481 return TRUE;
482}
483
484
485/***********************************************************************
486 * iterate_section_fields
487 *
488 * Iterate over all fields of a certain key of a certain section
489 */
490static BOOL iterate_section_fields( HINF hinf, PCWSTR section, PCWSTR key,
491 iterate_fields_func callback, void *arg )
492{
493 WCHAR static_buffer[200];
494 WCHAR *buffer = static_buffer;
495 DWORD size = sizeof(static_buffer)/sizeof(WCHAR);
496 INFCONTEXT context;
497 BOOL ret = FALSE;
498
499 BOOL ok = SetupFindFirstLineW( hinf, section, key, &context );
500 while (ok)
501 {
502 UINT i, count = SetupGetFieldCount( &context );
503 for (i = 1; i <= count; i++)
504 {
505 if (!(buffer = get_field_string( &context, i, buffer, static_buffer, &size )))
506 goto done;
507 if (!callback( hinf, buffer, arg ))
508 {
509 ERR("callback failed for %s %s\n", debugstr_w(section), debugstr_w(buffer) );
510 goto done;
511 }
512 }
513 ok = SetupFindNextMatchLineW( &context, key, &context );
514 }
515 ret = TRUE;
516 done:
517 if (buffer && buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
518 return ret;
519}
520
521
522/***********************************************************************
523 * SetupInstallFilesFromInfSectionA (SETUPAPI.@)
524 */
525BOOL WINAPI SetupInstallFilesFromInfSectionA( HINF hinf, HINF hlayout, HSPFILEQ queue,
526 PCSTR section, PCSTR src_root, UINT flags )
527{
528 UNICODE_STRING sectionW;
529 BOOL ret = FALSE;
530
531 if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
532 {
533 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
534 return FALSE;
535 }
536 if (!src_root)
537 ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
538 NULL, flags );
539 else
540 {
541 UNICODE_STRING srcW;
542 if (RtlCreateUnicodeStringFromAsciiz( &srcW, src_root ))
543 {
544 ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
545 srcW.Buffer, flags );
546 RtlFreeUnicodeString( &srcW );
547 }
548 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
549 }
550 RtlFreeUnicodeString( &sectionW );
551 return ret;
552}
553
554
555/***********************************************************************
556 * SetupInstallFilesFromInfSectionW (SETUPAPI.@)
557 */
558BOOL WINAPI SetupInstallFilesFromInfSectionW( HINF hinf, HINF hlayout, HSPFILEQ queue,
559 PCWSTR section, PCWSTR src_root, UINT flags )
560{
561 struct files_callback_info info;
562
563 info.queue = queue;
564 info.src_root = src_root;
565 info.copy_flags = flags;
566 info.layout = hlayout;
567 return iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info );
568}
569
570
571/***********************************************************************
572 * SetupInstallFromInfSectionA (SETUPAPI.@)
573 */
574BOOL WINAPI SetupInstallFromInfSectionA( HWND owner, HINF hinf, PCSTR section, UINT flags,
575 HKEY key_root, PCSTR src_root, UINT copy_flags,
576 PSP_FILE_CALLBACK_A callback, PVOID context,
577 HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
578{
579 UNICODE_STRING sectionW, src_rootW;
580 struct callback_WtoA_context ctx;
581 BOOL ret = FALSE;
582
583 src_rootW.Buffer = NULL;
584 if (src_root && !RtlCreateUnicodeStringFromAsciiz( &src_rootW, src_root ))
585 {
586 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
587 return FALSE;
588 }
589
590 if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
591 {
592 ctx.orig_context = context;
593 ctx.orig_handler = callback;
594 ret = SetupInstallFromInfSectionW( owner, hinf, sectionW.Buffer, flags, key_root,
595 src_rootW.Buffer, copy_flags, QUEUE_callback_WtoA,
596 &ctx, devinfo, devinfo_data );
597 RtlFreeUnicodeString( &sectionW );
598 }
599 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
600
601 RtlFreeUnicodeString( &src_rootW );
602 return ret;
603}
604
605
606/***********************************************************************
607 * SetupInstallFromInfSectionW (SETUPAPI.@)
608 */
609BOOL WINAPI SetupInstallFromInfSectionW( HWND owner, HINF hinf, PCWSTR section, UINT flags,
610 HKEY key_root, PCWSTR src_root, UINT copy_flags,
611 PSP_FILE_CALLBACK_W callback, PVOID context,
612 HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
613{
614 if (flags & SPINST_FILES)
615 {
616 struct files_callback_info info;
617 HSPFILEQ queue;
618 BOOL ret;
619
620 if (!(queue = SetupOpenFileQueue())) return FALSE;
621 info.queue = queue;
622 info.src_root = src_root;
623 info.copy_flags = copy_flags;
624 info.layout = hinf;
625 ret = (iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info ) &&
626 iterate_section_fields( hinf, section, DelFiles, delete_files_callback, &info ) &&
627 iterate_section_fields( hinf, section, RenFiles, rename_files_callback, &info ) &&
628 SetupCommitFileQueueW( owner, queue, callback, context ));
629 SetupCloseFileQueue( queue );
630 if (!ret) return FALSE;
631 }
632 if (flags & SPINST_INIFILES)
633 {
634 if (!iterate_section_fields( hinf, section, UpdateInis, update_ini_callback, NULL ) ||
635 !iterate_section_fields( hinf, section, UpdateIniFields,
636 update_ini_fields_callback, NULL ))
637 return FALSE;
638 }
639 if (flags & SPINST_INI2REG)
640 {
641 if (!iterate_section_fields( hinf, section, Ini2Reg, ini2reg_callback, NULL ))
642 return FALSE;
643 }
644
645 if (flags & SPINST_LOGCONFIG)
646 {
647 if (!iterate_section_fields( hinf, section, LogConf, logconf_callback, NULL ))
648 return FALSE;
649 }
650
651 if (flags & SPINST_REGISTRY)
652 {
653 struct registry_callback_info info;
654
655 info.default_root = key_root;
656 info.delete = TRUE;
657 if (!iterate_section_fields( hinf, section, DelReg, registry_callback, &info ))
658 return FALSE;
659 info.delete = FALSE;
660 if (!iterate_section_fields( hinf, section, AddReg, registry_callback, &info ))
661 return FALSE;
662 }
663 if (flags & (SPINST_BITREG|SPINST_REGSVR|SPINST_UNREGSVR|SPINST_PROFILEITEMS|SPINST_COPYINF))
664 FIXME( "unsupported flags %x\n", flags );
665 return TRUE;
666}
Note: See TracBrowser for help on using the repository browser.