source: trunk/src/setupapi/install.c@ 8421

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

wine resync
File size: 21.2 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 "ntddk.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 ? wcstol( 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 %08x %s\n", root_key, debugstr_w(buffer) );
397 continue;
398 }
399 TRACE( "key %08x %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 FIXME( "should update ini %s\n", debugstr_w(field) );
420 return TRUE;
421}
422
423static BOOL update_ini_fields_callback( HINF hinf, PCWSTR field, void *arg )
424{
425 FIXME( "should update ini fields %s\n", debugstr_w(field) );
426 return TRUE;
427}
428
429static BOOL ini2reg_callback( HINF hinf, PCWSTR field, void *arg )
430{
431 FIXME( "should do ini2reg %s\n", debugstr_w(field) );
432 return TRUE;
433}
434
435static BOOL logconf_callback( HINF hinf, PCWSTR field, void *arg )
436{
437 FIXME( "should do logconf %s\n", debugstr_w(field) );
438 return TRUE;
439}
440
441
442/***********************************************************************
443 * iterate_section_fields
444 *
445 * Iterate over all fields of a certain key of a certain section
446 */
447static BOOL iterate_section_fields( HINF hinf, PCWSTR section, PCWSTR key,
448 iterate_fields_func callback, void *arg )
449{
450 WCHAR static_buffer[200];
451 WCHAR *buffer = static_buffer;
452 DWORD size = sizeof(static_buffer)/sizeof(WCHAR);
453 INFCONTEXT context;
454 BOOL ret = FALSE;
455
456 BOOL ok = SetupFindFirstLineW( hinf, section, key, &context );
457 while (ok)
458 {
459 UINT i, count = SetupGetFieldCount( &context );
460 for (i = 1; i <= count; i++)
461 {
462 if (!(buffer = get_field_string( &context, i, buffer, static_buffer, &size )))
463 goto done;
464 if (!callback( hinf, buffer, arg ))
465 {
466 ERR("callback failed for %s %s\n", debugstr_w(section), debugstr_w(buffer) );
467 goto done;
468 }
469 }
470 ok = SetupFindNextMatchLineW( &context, key, &context );
471 }
472 ret = TRUE;
473 done:
474 if (buffer && buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
475 return ret;
476}
477
478
479/***********************************************************************
480 * SetupInstallFilesFromInfSectionA (SETUPAPI.@)
481 */
482BOOL WINAPI SetupInstallFilesFromInfSectionA( HINF hinf, HINF hlayout, HSPFILEQ queue,
483 PCSTR section, PCSTR src_root, UINT flags )
484{
485 UNICODE_STRING sectionW;
486 BOOL ret = FALSE;
487
488 if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
489 {
490 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
491 return FALSE;
492 }
493 if (!src_root)
494 ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
495 NULL, flags );
496 else
497 {
498 UNICODE_STRING srcW;
499 if (RtlCreateUnicodeStringFromAsciiz( &srcW, src_root ))
500 {
501 ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
502 srcW.Buffer, flags );
503 RtlFreeUnicodeString( &srcW );
504 }
505 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
506 }
507 RtlFreeUnicodeString( &sectionW );
508 return ret;
509}
510
511
512/***********************************************************************
513 * SetupInstallFilesFromInfSectionW (SETUPAPI.@)
514 */
515BOOL WINAPI SetupInstallFilesFromInfSectionW( HINF hinf, HINF hlayout, HSPFILEQ queue,
516 PCWSTR section, PCWSTR src_root, UINT flags )
517{
518 struct files_callback_info info;
519
520 info.queue = queue;
521 info.src_root = src_root;
522 info.copy_flags = flags;
523 info.layout = hlayout;
524 return iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info );
525}
526
527
528/***********************************************************************
529 * SetupInstallFromInfSectionA (SETUPAPI.@)
530 */
531BOOL WINAPI SetupInstallFromInfSectionA( HWND owner, HINF hinf, PCSTR section, UINT flags,
532 HKEY key_root, PCSTR src_root, UINT copy_flags,
533 PSP_FILE_CALLBACK_A callback, PVOID context,
534 HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
535{
536 UNICODE_STRING sectionW, src_rootW;
537 struct callback_WtoA_context ctx;
538 BOOL ret = FALSE;
539
540 src_rootW.Buffer = NULL;
541 if (src_root && !RtlCreateUnicodeStringFromAsciiz( &src_rootW, src_root ))
542 {
543 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
544 return FALSE;
545 }
546
547 if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
548 {
549 ctx.orig_context = context;
550 ctx.orig_handler = callback;
551 ret = SetupInstallFromInfSectionW( owner, hinf, sectionW.Buffer, flags, key_root,
552 src_rootW.Buffer, copy_flags, QUEUE_callback_WtoA,
553 &ctx, devinfo, devinfo_data );
554 RtlFreeUnicodeString( &sectionW );
555 }
556 else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
557
558 RtlFreeUnicodeString( &src_rootW );
559 return ret;
560}
561
562
563/***********************************************************************
564 * SetupInstallFromInfSectionW (SETUPAPI.@)
565 */
566BOOL WINAPI SetupInstallFromInfSectionW( HWND owner, HINF hinf, PCWSTR section, UINT flags,
567 HKEY key_root, PCWSTR src_root, UINT copy_flags,
568 PSP_FILE_CALLBACK_W callback, PVOID context,
569 HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
570{
571 if (flags & SPINST_FILES)
572 {
573 struct files_callback_info info;
574 HSPFILEQ queue;
575 BOOL ret;
576
577 if (!(queue = SetupOpenFileQueue())) return FALSE;
578 info.queue = queue;
579 info.src_root = src_root;
580 info.copy_flags = copy_flags;
581 info.layout = hinf;
582 ret = (iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info ) &&
583 iterate_section_fields( hinf, section, DelFiles, delete_files_callback, &info ) &&
584 iterate_section_fields( hinf, section, RenFiles, rename_files_callback, &info ) &&
585 SetupCommitFileQueueW( owner, queue, callback, context ));
586 SetupCloseFileQueue( queue );
587 if (!ret) return FALSE;
588 }
589 if (flags & SPINST_INIFILES)
590 {
591 if (!iterate_section_fields( hinf, section, UpdateInis, update_ini_callback, NULL ) ||
592 !iterate_section_fields( hinf, section, UpdateIniFields,
593 update_ini_fields_callback, NULL ))
594 return FALSE;
595 }
596 if (flags & SPINST_INI2REG)
597 {
598 if (!iterate_section_fields( hinf, section, Ini2Reg, ini2reg_callback, NULL ))
599 return FALSE;
600 }
601
602 if (flags & SPINST_LOGCONFIG)
603 {
604 if (!iterate_section_fields( hinf, section, LogConf, logconf_callback, NULL ))
605 return FALSE;
606 }
607
608 if (flags & SPINST_REGISTRY)
609 {
610 struct registry_callback_info info;
611
612 info.default_root = key_root;
613 info.delete = FALSE;
614 if (!iterate_section_fields( hinf, section, AddReg, registry_callback, &info ))
615 return FALSE;
616 info.delete = TRUE;
617 if (!iterate_section_fields( hinf, section, DelReg, registry_callback, &info ))
618 return FALSE;
619 }
620 if (flags & (SPINST_BITREG|SPINST_REGSVR|SPINST_UNREGSVR|SPINST_PROFILEITEMS|SPINST_COPYINF))
621 FIXME( "unsupported flags %x\n", flags );
622 return TRUE;
623}
Note: See TracBrowser for help on using the repository browser.