ntdll: Fix RtlValidAcl to accept newer ACL revisions.
[wine] / dlls / setupapi / install.c
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19  */
20
21 #include <stdarg.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winreg.h"
26 #include "winternl.h"
27 #include "winerror.h"
28 #include "wingdi.h"
29 #include "winuser.h"
30 #include "winnls.h"
31 #include "setupapi.h"
32 #include "setupapi_private.h"
33 #include "wine/unicode.h"
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
37
38 /* info passed to callback functions dealing with files */
39 struct files_callback_info
40 {
41     HSPFILEQ queue;
42     PCWSTR   src_root;
43     UINT     copy_flags;
44     HINF     layout;
45 };
46
47 /* info passed to callback functions dealing with the registry */
48 struct registry_callback_info
49 {
50     HKEY default_root;
51     BOOL delete;
52 };
53
54 /* info passed to callback functions dealing with registering dlls */
55 struct register_dll_info
56 {
57     PSP_FILE_CALLBACK_W callback;
58     PVOID               callback_context;
59     BOOL                unregister;
60 };
61
62 typedef BOOL (*iterate_fields_func)( HINF hinf, PCWSTR field, void *arg );
63
64 /* Unicode constants */
65 static const WCHAR CopyFiles[]  = {'C','o','p','y','F','i','l','e','s',0};
66 static const WCHAR DelFiles[]   = {'D','e','l','F','i','l','e','s',0};
67 static const WCHAR RenFiles[]   = {'R','e','n','F','i','l','e','s',0};
68 static const WCHAR Ini2Reg[]    = {'I','n','i','2','R','e','g',0};
69 static const WCHAR LogConf[]    = {'L','o','g','C','o','n','f',0};
70 static const WCHAR AddReg[]     = {'A','d','d','R','e','g',0};
71 static const WCHAR DelReg[]     = {'D','e','l','R','e','g',0};
72 static const WCHAR BitReg[]     = {'B','i','t','R','e','g',0};
73 static const WCHAR UpdateInis[] = {'U','p','d','a','t','e','I','n','i','s',0};
74 static const WCHAR CopyINF[]    = {'C','o','p','y','I','N','F',0};
75 static const WCHAR UpdateIniFields[] = {'U','p','d','a','t','e','I','n','i','F','i','e','l','d','s',0};
76 static const WCHAR RegisterDlls[]    = {'R','e','g','i','s','t','e','r','D','l','l','s',0};
77 static const WCHAR UnregisterDlls[]  = {'U','n','r','e','g','i','s','t','e','r','D','l','l','s',0};
78 static const WCHAR ProfileItems[]    = {'P','r','o','f','i','l','e','I','t','e','m','s',0};
79 static const WCHAR WineFakeDlls[]    = {'W','i','n','e','F','a','k','e','D','l','l','s',0};
80
81
82 /***********************************************************************
83  *            get_field_string
84  *
85  * Retrieve the contents of a field, dynamically growing the buffer if necessary.
86  */
87 static WCHAR *get_field_string( INFCONTEXT *context, DWORD index, WCHAR *buffer,
88                                 WCHAR *static_buffer, DWORD *size )
89 {
90     DWORD required;
91
92     if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
93     if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
94     {
95         /* now grow the buffer */
96         if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
97         if (!(buffer = HeapAlloc( GetProcessHeap(), 0, required*sizeof(WCHAR) ))) return NULL;
98         *size = required;
99         if (SetupGetStringFieldW( context, index, buffer, *size, &required )) return buffer;
100     }
101     if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
102     return NULL;
103 }
104
105
106 /***********************************************************************
107  *            copy_files_callback
108  *
109  * Called once for each CopyFiles entry in a given section.
110  */
111 static BOOL copy_files_callback( HINF hinf, PCWSTR field, void *arg )
112 {
113     struct files_callback_info *info = arg;
114
115     if (field[0] == '@')  /* special case: copy single file */
116         SetupQueueDefaultCopyW( info->queue, info->layout ? info->layout : hinf, info->src_root, NULL, field+1, info->copy_flags );
117     else
118         SetupQueueCopySectionW( info->queue, info->src_root, info->layout ? info->layout : hinf, hinf, field, info->copy_flags );
119     return TRUE;
120 }
121
122
123 /***********************************************************************
124  *            delete_files_callback
125  *
126  * Called once for each DelFiles entry in a given section.
127  */
128 static BOOL delete_files_callback( HINF hinf, PCWSTR field, void *arg )
129 {
130     struct files_callback_info *info = arg;
131     SetupQueueDeleteSectionW( info->queue, hinf, 0, field );
132     return TRUE;
133 }
134
135
136 /***********************************************************************
137  *            rename_files_callback
138  *
139  * Called once for each RenFiles entry in a given section.
140  */
141 static BOOL rename_files_callback( HINF hinf, PCWSTR field, void *arg )
142 {
143     struct files_callback_info *info = arg;
144     SetupQueueRenameSectionW( info->queue, hinf, 0, field );
145     return TRUE;
146 }
147
148
149 /***********************************************************************
150  *            get_root_key
151  *
152  * Retrieve the registry root key from its name.
153  */
154 static HKEY get_root_key( const WCHAR *name, HKEY def_root )
155 {
156     static const WCHAR HKCR[] = {'H','K','C','R',0};
157     static const WCHAR HKCU[] = {'H','K','C','U',0};
158     static const WCHAR HKLM[] = {'H','K','L','M',0};
159     static const WCHAR HKU[]  = {'H','K','U',0};
160     static const WCHAR HKR[]  = {'H','K','R',0};
161
162     if (!strcmpiW( name, HKCR )) return HKEY_CLASSES_ROOT;
163     if (!strcmpiW( name, HKCU )) return HKEY_CURRENT_USER;
164     if (!strcmpiW( name, HKLM )) return HKEY_LOCAL_MACHINE;
165     if (!strcmpiW( name, HKU )) return HKEY_USERS;
166     if (!strcmpiW( name, HKR )) return def_root;
167     return 0;
168 }
169
170
171 /***********************************************************************
172  *            append_multi_sz_value
173  *
174  * Append a multisz string to a multisz registry value.
175  */
176 static void append_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *strings,
177                                    DWORD str_size )
178 {
179     DWORD size, type, total;
180     WCHAR *buffer, *p;
181
182     if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
183     if (type != REG_MULTI_SZ) return;
184
185     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, (size + str_size) * sizeof(WCHAR) ))) return;
186     if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
187
188     /* compare each string against all the existing ones */
189     total = size;
190     while (*strings)
191     {
192         int len = strlenW(strings) + 1;
193
194         for (p = buffer; *p; p += strlenW(p) + 1)
195             if (!strcmpiW( p, strings )) break;
196
197         if (!*p)  /* not found, need to append it */
198         {
199             memcpy( p, strings, len * sizeof(WCHAR) );
200             p[len] = 0;
201             total += len;
202         }
203         strings += len;
204     }
205     if (total != size)
206     {
207         TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer) );
208         RegSetValueExW( hkey, value, 0, REG_MULTI_SZ, (BYTE *)buffer, total );
209     }
210  done:
211     HeapFree( GetProcessHeap(), 0, buffer );
212 }
213
214
215 /***********************************************************************
216  *            delete_multi_sz_value
217  *
218  * Remove a string from a multisz registry value.
219  */
220 static void delete_multi_sz_value( HKEY hkey, const WCHAR *value, const WCHAR *string )
221 {
222     DWORD size, type;
223     WCHAR *buffer, *src, *dst;
224
225     if (RegQueryValueExW( hkey, value, NULL, &type, NULL, &size )) return;
226     if (type != REG_MULTI_SZ) return;
227     /* allocate double the size, one for value before and one for after */
228     if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size * 2 * sizeof(WCHAR) ))) return;
229     if (RegQueryValueExW( hkey, value, NULL, NULL, (BYTE *)buffer, &size )) goto done;
230     src = buffer;
231     dst = buffer + size;
232     while (*src)
233     {
234         int len = strlenW(src) + 1;
235         if (strcmpiW( src, string ))
236         {
237             memcpy( dst, src, len * sizeof(WCHAR) );
238             dst += len;
239         }
240         src += len;
241     }
242     *dst++ = 0;
243     if (dst != buffer + 2*size)  /* did we remove something? */
244     {
245         TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(buffer + size) );
246         RegSetValueExW( hkey, value, 0, REG_MULTI_SZ,
247                         (BYTE *)(buffer + size), dst - (buffer + size) );
248     }
249  done:
250     HeapFree( GetProcessHeap(), 0, buffer );
251 }
252
253
254 /***********************************************************************
255  *            do_reg_operation
256  *
257  * Perform an add/delete registry operation depending on the flags.
258  */
259 static BOOL do_reg_operation( HKEY hkey, const WCHAR *value, INFCONTEXT *context, INT flags )
260 {
261     DWORD type, size;
262
263     if (flags & (FLG_ADDREG_DELREG_BIT | FLG_ADDREG_DELVAL))  /* deletion */
264     {
265         if (*value && !(flags & FLG_DELREG_KEYONLY_COMMON))
266         {
267             if ((flags & FLG_DELREG_MULTI_SZ_DELSTRING) == FLG_DELREG_MULTI_SZ_DELSTRING)
268             {
269                 WCHAR *str;
270
271                 if (!SetupGetStringFieldW( context, 5, NULL, 0, &size ) || !size) return TRUE;
272                 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
273                 SetupGetStringFieldW( context, 5, str, size, NULL );
274                 delete_multi_sz_value( hkey, value, str );
275                 HeapFree( GetProcessHeap(), 0, str );
276             }
277             else RegDeleteValueW( hkey, value );
278         }
279         else NtDeleteKey( hkey );
280         return TRUE;
281     }
282
283     if (flags & (FLG_ADDREG_KEYONLY|FLG_ADDREG_KEYONLY_COMMON)) return TRUE;
284
285     if (flags & (FLG_ADDREG_NOCLOBBER|FLG_ADDREG_OVERWRITEONLY))
286     {
287         BOOL exists = !RegQueryValueExW( hkey, value, NULL, NULL, NULL, NULL );
288         if (exists && (flags & FLG_ADDREG_NOCLOBBER)) return TRUE;
289         if (!exists && (flags & FLG_ADDREG_OVERWRITEONLY)) return TRUE;
290     }
291
292     switch(flags & FLG_ADDREG_TYPE_MASK)
293     {
294     case FLG_ADDREG_TYPE_SZ:        type = REG_SZ; break;
295     case FLG_ADDREG_TYPE_MULTI_SZ:  type = REG_MULTI_SZ; break;
296     case FLG_ADDREG_TYPE_EXPAND_SZ: type = REG_EXPAND_SZ; break;
297     case FLG_ADDREG_TYPE_BINARY:    type = REG_BINARY; break;
298     case FLG_ADDREG_TYPE_DWORD:     type = REG_DWORD; break;
299     case FLG_ADDREG_TYPE_NONE:      type = REG_NONE; break;
300     default:                        type = flags >> 16; break;
301     }
302
303     if (!(flags & FLG_ADDREG_BINVALUETYPE) ||
304         (type == REG_DWORD && SetupGetFieldCount(context) == 5))
305     {
306         static const WCHAR empty;
307         WCHAR *str = NULL;
308
309         if (type == REG_MULTI_SZ)
310         {
311             if (!SetupGetMultiSzFieldW( context, 5, NULL, 0, &size )) size = 0;
312             if (size)
313             {
314                 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
315                 SetupGetMultiSzFieldW( context, 5, str, size, NULL );
316             }
317             if (flags & FLG_ADDREG_APPEND)
318             {
319                 if (!str) return TRUE;
320                 append_multi_sz_value( hkey, value, str, size );
321                 HeapFree( GetProcessHeap(), 0, str );
322                 return TRUE;
323             }
324             /* else fall through to normal string handling */
325         }
326         else
327         {
328             if (!SetupGetStringFieldW( context, 5, NULL, 0, &size )) size = 0;
329             if (size)
330             {
331                 if (!(str = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return FALSE;
332                 SetupGetStringFieldW( context, 5, str, size, NULL );
333             }
334         }
335
336         if (type == REG_DWORD)
337         {
338             DWORD dw = str ? strtoulW( str, NULL, 0 ) : 0;
339             TRACE( "setting dword %s to %x\n", debugstr_w(value), dw );
340             RegSetValueExW( hkey, value, 0, type, (BYTE *)&dw, sizeof(dw) );
341         }
342         else
343         {
344             TRACE( "setting value %s to %s\n", debugstr_w(value), debugstr_w(str) );
345             if (str) RegSetValueExW( hkey, value, 0, type, (BYTE *)str, size * sizeof(WCHAR) );
346             else RegSetValueExW( hkey, value, 0, type, (const BYTE *)&empty, sizeof(WCHAR) );
347         }
348         HeapFree( GetProcessHeap(), 0, str );
349         return TRUE;
350     }
351     else  /* get the binary data */
352     {
353         BYTE *data = NULL;
354
355         if (!SetupGetBinaryField( context, 5, NULL, 0, &size )) size = 0;
356         if (size)
357         {
358             if (!(data = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
359             TRACE( "setting binary data %s len %d\n", debugstr_w(value), size );
360             SetupGetBinaryField( context, 5, data, size, NULL );
361         }
362         RegSetValueExW( hkey, value, 0, type, data, size );
363         HeapFree( GetProcessHeap(), 0, data );
364         return TRUE;
365     }
366 }
367
368
369 /***********************************************************************
370  *            registry_callback
371  *
372  * Called once for each AddReg and DelReg entry in a given section.
373  */
374 static BOOL registry_callback( HINF hinf, PCWSTR field, void *arg )
375 {
376     struct registry_callback_info *info = arg;
377     INFCONTEXT context;
378     HKEY root_key, hkey;
379
380     BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
381
382     for (; ok; ok = SetupFindNextLine( &context, &context ))
383     {
384         WCHAR buffer[MAX_INF_STRING_LENGTH];
385         INT flags;
386
387         /* get root */
388         if (!SetupGetStringFieldW( &context, 1, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
389             continue;
390         if (!(root_key = get_root_key( buffer, info->default_root )))
391             continue;
392
393         /* get key */
394         if (!SetupGetStringFieldW( &context, 2, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
395             *buffer = 0;
396
397         /* get flags */
398         if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
399
400         if (!info->delete)
401         {
402             if (flags & FLG_ADDREG_DELREG_BIT) continue;  /* ignore this entry */
403         }
404         else
405         {
406             if (!flags) flags = FLG_ADDREG_DELREG_BIT;
407             else if (!(flags & FLG_ADDREG_DELREG_BIT)) continue;  /* ignore this entry */
408         }
409
410         if (info->delete || (flags & FLG_ADDREG_OVERWRITEONLY))
411         {
412             if (RegOpenKeyW( root_key, buffer, &hkey )) continue;  /* ignore if it doesn't exist */
413         }
414         else if (RegCreateKeyW( root_key, buffer, &hkey ))
415         {
416             ERR( "could not create key %p %s\n", root_key, debugstr_w(buffer) );
417             continue;
418         }
419         TRACE( "key %p %s\n", root_key, debugstr_w(buffer) );
420
421         /* get value name */
422         if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
423             *buffer = 0;
424
425         /* and now do it */
426         if (!do_reg_operation( hkey, buffer, &context, flags ))
427         {
428             RegCloseKey( hkey );
429             return FALSE;
430         }
431         RegCloseKey( hkey );
432     }
433     return TRUE;
434 }
435
436
437 /***********************************************************************
438  *            do_register_dll
439  *
440  * Register or unregister a dll.
441  */
442 static BOOL do_register_dll( const struct register_dll_info *info, const WCHAR *path,
443                              INT flags, INT timeout, const WCHAR *args )
444 {
445     HMODULE module;
446     HRESULT res;
447     SP_REGISTER_CONTROL_STATUSW status;
448     IMAGE_NT_HEADERS *nt;
449
450     status.cbSize = sizeof(status);
451     status.FileName = path;
452     status.FailureCode = SPREG_SUCCESS;
453     status.Win32Error = ERROR_SUCCESS;
454
455     if (info->callback)
456     {
457         switch(info->callback( info->callback_context, SPFILENOTIFY_STARTREGISTRATION,
458                                (UINT_PTR)&status, !info->unregister ))
459         {
460         case FILEOP_ABORT:
461             SetLastError( ERROR_OPERATION_ABORTED );
462             return FALSE;
463         case FILEOP_SKIP:
464             return TRUE;
465         case FILEOP_DOIT:
466             break;
467         }
468     }
469
470     if (!(module = LoadLibraryExW( path, 0, LOAD_WITH_ALTERED_SEARCH_PATH )))
471     {
472         WARN( "could not load %s\n", debugstr_w(path) );
473         status.FailureCode = SPREG_LOADLIBRARY;
474         status.Win32Error = GetLastError();
475         goto done;
476     }
477
478     if ((nt = RtlImageNtHeader( module )) && !(nt->FileHeader.Characteristics & IMAGE_FILE_DLL))
479     {
480         /* file is an executable, not a dll */
481         STARTUPINFOW startup;
482         PROCESS_INFORMATION info;
483         WCHAR *cmd_line;
484         BOOL res;
485         static const WCHAR format[] = {'"','%','s','"',' ','%','s',0};
486         static const WCHAR default_args[] = {'/','R','e','g','S','e','r','v','e','r',0};
487
488         FreeLibrary( module );
489         module = NULL;
490         if (!args) args = default_args;
491         cmd_line = HeapAlloc( GetProcessHeap(), 0, (strlenW(path) + strlenW(args) + 4) * sizeof(WCHAR) );
492         sprintfW( cmd_line, format, path, args );
493         memset( &startup, 0, sizeof(startup) );
494         startup.cb = sizeof(startup);
495         TRACE( "executing %s\n", debugstr_w(cmd_line) );
496         res = CreateProcessW( NULL, cmd_line, NULL, NULL, FALSE, 0, NULL, NULL, &startup, &info );
497         HeapFree( GetProcessHeap(), 0, cmd_line );
498         if (!res)
499         {
500             status.FailureCode = SPREG_LOADLIBRARY;
501             status.Win32Error = GetLastError();
502             goto done;
503         }
504         CloseHandle( info.hThread );
505
506         if (WaitForSingleObject( info.hProcess, timeout*1000 ) == WAIT_TIMEOUT)
507         {
508             /* timed out, kill the process */
509             TerminateProcess( info.hProcess, 1 );
510             status.FailureCode = SPREG_TIMEOUT;
511             status.Win32Error = ERROR_TIMEOUT;
512         }
513         CloseHandle( info.hProcess );
514         goto done;
515     }
516
517     if (flags & FLG_REGSVR_DLLREGISTER)
518     {
519         const char *entry_point = info->unregister ? "DllUnregisterServer" : "DllRegisterServer";
520         HRESULT (WINAPI *func)(void) = (void *)GetProcAddress( module, entry_point );
521
522         if (!func)
523         {
524             status.FailureCode = SPREG_GETPROCADDR;
525             status.Win32Error = GetLastError();
526             goto done;
527         }
528
529         TRACE( "calling %s in %s\n", entry_point, debugstr_w(path) );
530         res = func();
531
532         if (FAILED(res))
533         {
534             WARN( "calling %s in %s returned error %x\n", entry_point, debugstr_w(path), res );
535             status.FailureCode = SPREG_REGSVR;
536             status.Win32Error = res;
537             goto done;
538         }
539     }
540
541     if (flags & FLG_REGSVR_DLLINSTALL)
542     {
543         HRESULT (WINAPI *func)(BOOL,LPCWSTR) = (void *)GetProcAddress( module, "DllInstall" );
544
545         if (!func)
546         {
547             status.FailureCode = SPREG_GETPROCADDR;
548             status.Win32Error = GetLastError();
549             goto done;
550         }
551
552         TRACE( "calling DllInstall(%d,%s) in %s\n",
553                !info->unregister, debugstr_w(args), debugstr_w(path) );
554         res = func( !info->unregister, args );
555
556         if (FAILED(res))
557         {
558             WARN( "calling DllInstall in %s returned error %x\n", debugstr_w(path), res );
559             status.FailureCode = SPREG_REGSVR;
560             status.Win32Error = res;
561             goto done;
562         }
563     }
564
565 done:
566     if (module) FreeLibrary( module );
567     if (info->callback) info->callback( info->callback_context, SPFILENOTIFY_ENDREGISTRATION,
568                                         (UINT_PTR)&status, !info->unregister );
569     return TRUE;
570 }
571
572
573 /***********************************************************************
574  *            register_dlls_callback
575  *
576  * Called once for each RegisterDlls entry in a given section.
577  */
578 static BOOL register_dlls_callback( HINF hinf, PCWSTR field, void *arg )
579 {
580     struct register_dll_info *info = arg;
581     INFCONTEXT context;
582     BOOL ret = TRUE;
583     BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
584
585     for (; ok; ok = SetupFindNextLine( &context, &context ))
586     {
587         WCHAR *path, *args, *p;
588         WCHAR buffer[MAX_INF_STRING_LENGTH];
589         INT flags, timeout;
590
591         /* get directory */
592         if (!(path = PARSER_get_dest_dir( &context ))) continue;
593
594         /* get dll name */
595         if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
596             goto done;
597         if (!(p = HeapReAlloc( GetProcessHeap(), 0, path,
598                                (strlenW(path) + strlenW(buffer) + 2) * sizeof(WCHAR) ))) goto done;
599         path = p;
600         p += strlenW(p);
601         if (p == path || p[-1] != '\\') *p++ = '\\';
602         strcpyW( p, buffer );
603
604         /* get flags */
605         if (!SetupGetIntField( &context, 4, &flags )) flags = 0;
606
607         /* get timeout */
608         if (!SetupGetIntField( &context, 5, &timeout )) timeout = 60;
609
610         /* get command line */
611         args = NULL;
612         if (SetupGetStringFieldW( &context, 6, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
613             args = buffer;
614
615         ret = do_register_dll( info, path, flags, timeout, args );
616
617     done:
618         HeapFree( GetProcessHeap(), 0, path );
619         if (!ret) break;
620     }
621     return ret;
622 }
623
624 /***********************************************************************
625  *            fake_dlls_callback
626  *
627  * Called once for each WineFakeDlls entry in a given section.
628  */
629 static BOOL fake_dlls_callback( HINF hinf, PCWSTR field, void *arg )
630 {
631     INFCONTEXT context;
632     BOOL ret = TRUE;
633     BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
634
635     for (; ok; ok = SetupFindNextLine( &context, &context ))
636     {
637         WCHAR *path, *p;
638         WCHAR buffer[MAX_INF_STRING_LENGTH];
639
640         /* get directory */
641         if (!(path = PARSER_get_dest_dir( &context ))) continue;
642
643         /* get dll name */
644         if (!SetupGetStringFieldW( &context, 3, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
645             goto done;
646         if (!(p = HeapReAlloc( GetProcessHeap(), 0, path,
647                                (strlenW(path) + strlenW(buffer) + 2) * sizeof(WCHAR) ))) goto done;
648         path = p;
649         p += strlenW(p);
650         if (p == path || p[-1] != '\\') *p++ = '\\';
651         strcpyW( p, buffer );
652
653         /* get source dll */
654         if (SetupGetStringFieldW( &context, 4, buffer, sizeof(buffer)/sizeof(WCHAR), NULL ))
655             p = buffer;  /* otherwise use target base name as default source */
656
657         create_fake_dll( path, p );  /* ignore errors */
658
659     done:
660         HeapFree( GetProcessHeap(), 0, path );
661         if (!ret) break;
662     }
663     return ret;
664 }
665
666 /***********************************************************************
667  *            update_ini_callback
668  *
669  * Called once for each UpdateInis entry in a given section.
670  */
671 static BOOL update_ini_callback( HINF hinf, PCWSTR field, void *arg )
672 {
673     INFCONTEXT context;
674
675     BOOL ok = SetupFindFirstLineW( hinf, field, NULL, &context );
676
677     for (; ok; ok = SetupFindNextLine( &context, &context ))
678     {
679         WCHAR buffer[MAX_INF_STRING_LENGTH];
680         WCHAR  filename[MAX_INF_STRING_LENGTH];
681         WCHAR  section[MAX_INF_STRING_LENGTH];
682         WCHAR  entry[MAX_INF_STRING_LENGTH];
683         WCHAR  string[MAX_INF_STRING_LENGTH];
684         LPWSTR divider;
685
686         if (!SetupGetStringFieldW( &context, 1, filename,
687                                    sizeof(filename)/sizeof(WCHAR), NULL ))
688             continue;
689
690         if (!SetupGetStringFieldW( &context, 2, section,
691                                    sizeof(section)/sizeof(WCHAR), NULL ))
692             continue;
693
694         if (!SetupGetStringFieldW( &context, 4, buffer,
695                                    sizeof(buffer)/sizeof(WCHAR), NULL ))
696             continue;
697
698         divider = strchrW(buffer,'=');
699         if (divider)
700         {
701             *divider = 0;
702             strcpyW(entry,buffer);
703             divider++;
704             strcpyW(string,divider);
705         }
706         else
707         {
708             strcpyW(entry,buffer);
709             string[0]=0;
710         }
711
712         TRACE("Writing %s = %s in %s of file %s\n",debugstr_w(entry),
713                debugstr_w(string),debugstr_w(section),debugstr_w(filename));
714         WritePrivateProfileStringW(section,entry,string,filename);
715
716     }
717     return TRUE;
718 }
719
720 static BOOL update_ini_fields_callback( HINF hinf, PCWSTR field, void *arg )
721 {
722     FIXME( "should update ini fields %s\n", debugstr_w(field) );
723     return TRUE;
724 }
725
726 static BOOL ini2reg_callback( HINF hinf, PCWSTR field, void *arg )
727 {
728     FIXME( "should do ini2reg %s\n", debugstr_w(field) );
729     return TRUE;
730 }
731
732 static BOOL logconf_callback( HINF hinf, PCWSTR field, void *arg )
733 {
734     FIXME( "should do logconf %s\n", debugstr_w(field) );
735     return TRUE;
736 }
737
738 static BOOL bitreg_callback( HINF hinf, PCWSTR field, void *arg )
739 {
740     FIXME( "should do bitreg %s\n", debugstr_w(field) );
741     return TRUE;
742 }
743
744 static BOOL profile_items_callback( HINF hinf, PCWSTR field, void *arg )
745 {
746     FIXME( "should do profile items %s\n", debugstr_w(field) );
747     return TRUE;
748 }
749
750 static BOOL copy_inf_callback( HINF hinf, PCWSTR field, void *arg )
751 {
752     FIXME( "should do copy inf %s\n", debugstr_w(field) );
753     return TRUE;
754 }
755
756
757 /***********************************************************************
758  *            iterate_section_fields
759  *
760  * Iterate over all fields of a certain key of a certain section
761  */
762 static BOOL iterate_section_fields( HINF hinf, PCWSTR section, PCWSTR key,
763                                     iterate_fields_func callback, void *arg )
764 {
765     WCHAR static_buffer[200];
766     WCHAR *buffer = static_buffer;
767     DWORD size = sizeof(static_buffer)/sizeof(WCHAR);
768     INFCONTEXT context;
769     BOOL ret = FALSE;
770
771     BOOL ok = SetupFindFirstLineW( hinf, section, key, &context );
772     while (ok)
773     {
774         UINT i, count = SetupGetFieldCount( &context );
775         for (i = 1; i <= count; i++)
776         {
777             if (!(buffer = get_field_string( &context, i, buffer, static_buffer, &size )))
778                 goto done;
779             if (!callback( hinf, buffer, arg ))
780             {
781                 WARN("callback failed for %s %s err %d\n",
782                      debugstr_w(section), debugstr_w(buffer), GetLastError() );
783                 goto done;
784             }
785         }
786         ok = SetupFindNextMatchLineW( &context, key, &context );
787     }
788     ret = TRUE;
789  done:
790     if (buffer != static_buffer) HeapFree( GetProcessHeap(), 0, buffer );
791     return ret;
792 }
793
794
795 /***********************************************************************
796  *            SetupInstallFilesFromInfSectionA   (SETUPAPI.@)
797  */
798 BOOL WINAPI SetupInstallFilesFromInfSectionA( HINF hinf, HINF hlayout, HSPFILEQ queue,
799                                               PCSTR section, PCSTR src_root, UINT flags )
800 {
801     UNICODE_STRING sectionW;
802     BOOL ret = FALSE;
803
804     if (!RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
805     {
806         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
807         return FALSE;
808     }
809     if (!src_root)
810         ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
811                                                 NULL, flags );
812     else
813     {
814         UNICODE_STRING srcW;
815         if (RtlCreateUnicodeStringFromAsciiz( &srcW, src_root ))
816         {
817             ret = SetupInstallFilesFromInfSectionW( hinf, hlayout, queue, sectionW.Buffer,
818                                                     srcW.Buffer, flags );
819             RtlFreeUnicodeString( &srcW );
820         }
821         else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
822     }
823     RtlFreeUnicodeString( &sectionW );
824     return ret;
825 }
826
827
828 /***********************************************************************
829  *            SetupInstallFilesFromInfSectionW   (SETUPAPI.@)
830  */
831 BOOL WINAPI SetupInstallFilesFromInfSectionW( HINF hinf, HINF hlayout, HSPFILEQ queue,
832                                               PCWSTR section, PCWSTR src_root, UINT flags )
833 {
834     struct files_callback_info info;
835
836     info.queue      = queue;
837     info.src_root   = src_root;
838     info.copy_flags = flags;
839     info.layout     = hlayout;
840     return iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info );
841 }
842
843
844 /***********************************************************************
845  *            SetupInstallFromInfSectionA   (SETUPAPI.@)
846  */
847 BOOL WINAPI SetupInstallFromInfSectionA( HWND owner, HINF hinf, PCSTR section, UINT flags,
848                                          HKEY key_root, PCSTR src_root, UINT copy_flags,
849                                          PSP_FILE_CALLBACK_A callback, PVOID context,
850                                          HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
851 {
852     UNICODE_STRING sectionW, src_rootW;
853     struct callback_WtoA_context ctx;
854     BOOL ret = FALSE;
855
856     src_rootW.Buffer = NULL;
857     if (src_root && !RtlCreateUnicodeStringFromAsciiz( &src_rootW, src_root ))
858     {
859         SetLastError( ERROR_NOT_ENOUGH_MEMORY );
860         return FALSE;
861     }
862
863     if (RtlCreateUnicodeStringFromAsciiz( &sectionW, section ))
864     {
865         ctx.orig_context = context;
866         ctx.orig_handler = callback;
867         ret = SetupInstallFromInfSectionW( owner, hinf, sectionW.Buffer, flags, key_root,
868                                            src_rootW.Buffer, copy_flags, QUEUE_callback_WtoA,
869                                            &ctx, devinfo, devinfo_data );
870         RtlFreeUnicodeString( &sectionW );
871     }
872     else SetLastError( ERROR_NOT_ENOUGH_MEMORY );
873
874     RtlFreeUnicodeString( &src_rootW );
875     return ret;
876 }
877
878
879 /***********************************************************************
880  *            SetupInstallFromInfSectionW   (SETUPAPI.@)
881  */
882 BOOL WINAPI SetupInstallFromInfSectionW( HWND owner, HINF hinf, PCWSTR section, UINT flags,
883                                          HKEY key_root, PCWSTR src_root, UINT copy_flags,
884                                          PSP_FILE_CALLBACK_W callback, PVOID context,
885                                          HDEVINFO devinfo, PSP_DEVINFO_DATA devinfo_data )
886 {
887     if (flags & SPINST_FILES)
888     {
889         struct files_callback_info info;
890         HSPFILEQ queue;
891         BOOL ret;
892
893         if (!(queue = SetupOpenFileQueue())) return FALSE;
894         info.queue      = queue;
895         info.src_root   = src_root;
896         info.copy_flags = copy_flags;
897         info.layout     = hinf;
898         ret = (iterate_section_fields( hinf, section, CopyFiles, copy_files_callback, &info ) &&
899                iterate_section_fields( hinf, section, DelFiles, delete_files_callback, &info ) &&
900                iterate_section_fields( hinf, section, RenFiles, rename_files_callback, &info ) &&
901                SetupCommitFileQueueW( owner, queue, callback, context ));
902         SetupCloseFileQueue( queue );
903         if (!ret) return FALSE;
904     }
905     if (flags & SPINST_INIFILES)
906     {
907         if (!iterate_section_fields( hinf, section, UpdateInis, update_ini_callback, NULL ) ||
908             !iterate_section_fields( hinf, section, UpdateIniFields,
909                                      update_ini_fields_callback, NULL ))
910             return FALSE;
911     }
912     if (flags & SPINST_INI2REG)
913     {
914         if (!iterate_section_fields( hinf, section, Ini2Reg, ini2reg_callback, NULL ))
915             return FALSE;
916     }
917     if (flags & SPINST_LOGCONFIG)
918     {
919         if (!iterate_section_fields( hinf, section, LogConf, logconf_callback, NULL ))
920             return FALSE;
921     }
922     if (flags & SPINST_REGSVR)
923     {
924         struct register_dll_info info;
925
926         info.unregister = FALSE;
927         if (flags & SPINST_REGISTERCALLBACKAWARE)
928         {
929             info.callback         = callback;
930             info.callback_context = context;
931         }
932         else info.callback = NULL;
933
934         if (!iterate_section_fields( hinf, section, RegisterDlls, register_dlls_callback, &info ))
935             return FALSE;
936
937         if (!iterate_section_fields( hinf, section, WineFakeDlls, fake_dlls_callback, NULL ))
938             return FALSE;
939     }
940     if (flags & SPINST_UNREGSVR)
941     {
942         struct register_dll_info info;
943
944         info.unregister = TRUE;
945         if (flags & SPINST_REGISTERCALLBACKAWARE)
946         {
947             info.callback         = callback;
948             info.callback_context = context;
949         }
950         else info.callback = NULL;
951
952         if (!iterate_section_fields( hinf, section, UnregisterDlls, register_dlls_callback, &info ))
953             return FALSE;
954     }
955     if (flags & SPINST_REGISTRY)
956     {
957         struct registry_callback_info info;
958
959         info.default_root = key_root;
960         info.delete = TRUE;
961         if (!iterate_section_fields( hinf, section, DelReg, registry_callback, &info ))
962             return FALSE;
963         info.delete = FALSE;
964         if (!iterate_section_fields( hinf, section, AddReg, registry_callback, &info ))
965             return FALSE;
966     }
967     if (flags & SPINST_BITREG)
968     {
969         if (!iterate_section_fields( hinf, section, BitReg, bitreg_callback, NULL ))
970             return FALSE;
971     }
972     if (flags & SPINST_PROFILEITEMS)
973     {
974         if (!iterate_section_fields( hinf, section, ProfileItems, profile_items_callback, NULL ))
975             return FALSE;
976     }
977     if (flags & SPINST_COPYINF)
978     {
979         if (!iterate_section_fields( hinf, section, CopyINF, copy_inf_callback, NULL ))
980             return FALSE;
981     }
982
983     return TRUE;
984 }
985
986
987 /***********************************************************************
988  *              InstallHinfSectionW  (SETUPAPI.@)
989  *
990  * NOTE: 'cmdline' is <section> <mode> <path> from
991  *   RUNDLL32.EXE SETUPAPI.DLL,InstallHinfSection <section> <mode> <path>
992  */
993 void WINAPI InstallHinfSectionW( HWND hwnd, HINSTANCE handle, LPCWSTR cmdline, INT show )
994 {
995 #ifdef __i386__
996     static const WCHAR nt_platformW[] = {'.','n','t','x','8','6',0};
997 #elif defined(__x86_64)
998     static const WCHAR nt_platformW[] = {'.','n','t','a','m','d','6','4',0};
999 #else  /* FIXME: other platforms */
1000     static const WCHAR nt_platformW[] = {'.','n','t',0};
1001 #endif
1002     static const WCHAR nt_genericW[] = {'.','n','t',0};
1003
1004     WCHAR *s, *path, section[MAX_PATH + sizeof(nt_platformW)/sizeof(WCHAR)];
1005     void *callback_context;
1006     UINT mode;
1007     HINF hinf;
1008
1009     TRACE("hwnd %p, handle %p, cmdline %s\n", hwnd, handle, debugstr_w(cmdline));
1010
1011     lstrcpynW( section, cmdline, MAX_PATH );
1012
1013     if (!(s = strchrW( section, ' ' ))) return;
1014     *s++ = 0;
1015     while (*s == ' ') s++;
1016     mode = atoiW( s );
1017
1018     /* quoted paths are not allowed on native, the rest of the command line is taken as the path */
1019     if (!(s = strchrW( s, ' ' ))) return;
1020     while (*s == ' ') s++;
1021     path = s;
1022
1023     hinf = SetupOpenInfFileW( path, NULL, INF_STYLE_WIN4, NULL );
1024     if (hinf == INVALID_HANDLE_VALUE) return;
1025
1026     if (!(GetVersion() & 0x80000000))
1027     {
1028         INFCONTEXT context;
1029
1030         /* check for <section>.ntx86 (or corresponding name for the current platform)
1031          * and then <section>.nt */
1032         s = section + strlenW(section);
1033         memcpy( s, nt_platformW, sizeof(nt_platformW) );
1034         if (!(SetupFindFirstLineW( hinf, section, NULL, &context )))
1035         {
1036             memcpy( s, nt_genericW, sizeof(nt_genericW) );
1037             if (!(SetupFindFirstLineW( hinf, section, NULL, &context ))) *s = 0;
1038         }
1039         if (*s) TRACE( "using section %s instead\n", debugstr_w(section) );
1040     }
1041
1042     callback_context = SetupInitDefaultQueueCallback( hwnd );
1043     SetupInstallFromInfSectionW( hwnd, hinf, section, SPINST_ALL, NULL, NULL, SP_COPY_NEWER,
1044                                  SetupDefaultQueueCallbackW, callback_context,
1045                                  NULL, NULL );
1046     SetupTermDefaultQueueCallback( callback_context );
1047     SetupCloseInfFile( hinf );
1048
1049     /* FIXME: should check the mode and maybe reboot */
1050     /* there isn't much point in doing that since we */
1051     /* don't yet handle deferred file copies anyway. */
1052 }
1053
1054
1055 /***********************************************************************
1056  *              InstallHinfSectionA  (SETUPAPI.@)
1057  */
1058 void WINAPI InstallHinfSectionA( HWND hwnd, HINSTANCE handle, LPCSTR cmdline, INT show )
1059 {
1060     UNICODE_STRING cmdlineW;
1061
1062     if (RtlCreateUnicodeStringFromAsciiz( &cmdlineW, cmdline ))
1063     {
1064         InstallHinfSectionW( hwnd, handle, cmdlineW.Buffer, show );
1065         RtlFreeUnicodeString( &cmdlineW );
1066     }
1067 }
1068
1069 /***********************************************************************
1070  *              SetupInstallServicesFromInfSectionA  (SETUPAPI.@)
1071  */
1072 BOOL WINAPI SetupInstallServicesFromInfSectionA( HINF Inf, PCSTR SectionName, DWORD Flags)
1073 {
1074     FIXME("(%p, %s, %d) stub!\n", Inf, debugstr_a(SectionName), Flags);
1075     return FALSE;
1076 }