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