wintrust: Use path in WIN_TRUST_SUBJECT_FILE structure rather than assuming a path...
[wine] / dlls / advpack / install.c
1 /*
2  * Advpack install functions
3  *
4  * Copyright 2006 James Hawkins
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 #include <stdlib.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winuser.h"
27 #include "winreg.h"
28 #include "winternl.h"
29 #include "winnls.h"
30 #include "setupapi.h"
31 #include "advpub.h"
32 #include "ole2.h"
33 #include "wine/debug.h"
34 #include "wine/unicode.h"
35 #include "advpack_private.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(advpack);
38
39 #define SPAPI_ERROR     0xE0000000L
40 #define SPAPI_PREFIX    0x800F0000L
41 #define SPAPI_MASK      0xFFFFL
42 #define HRESULT_FROM_SPAPI(x)   ((x & SPAPI_MASK) | SPAPI_PREFIX)
43
44 #define ADV_HRESULT(x)  ((x & SPAPI_ERROR) ? HRESULT_FROM_SPAPI(x) : HRESULT_FROM_WIN32(x))
45
46 #define ADV_SUCCESS     0
47 #define ADV_FAILURE     1
48
49 /* contains information about a specific install instance */
50 typedef struct _ADVInfo
51 {
52     HINF hinf;
53     LPWSTR inf_path;
54     LPWSTR inf_filename;
55     LPWSTR install_sec;
56     LPWSTR working_dir;
57     DWORD flags;
58     BOOL need_reboot;
59 } ADVInfo;
60
61 typedef HRESULT (*iterate_fields_func)(HINF hinf, PCWSTR field, const void *arg);
62
63 /* Advanced INF commands */
64 static const WCHAR CheckAdminRights[] = {
65     'C','h','e','c','k','A','d','m','i','n','R','i','g','h','t','s',0
66 };
67 static const WCHAR DelDirs[] = {'D','e','l','D','i','r','s',0};
68 static const WCHAR PerUserInstall[] = {'P','e','r','U','s','e','r','I','n','s','t','a','l','l',0};
69 static const WCHAR RegisterOCXs[] = {'R','e','g','i','s','t','e','r','O','C','X','s',0};
70 static const WCHAR RunPreSetupCommands[] = {
71     'R','u','n','P','r','e','S','e','t','u','p','C','o','m','m','a','n','d','s',0
72 };
73 static const WCHAR RunPostSetupCommands[] = {
74     'R','u','n','P','o','s','t','S','e','t','u','p','C','o','m','m','a','n','d','s',0
75 };
76
77 /* Advanced INF callbacks */
78 static HRESULT del_dirs_callback(HINF hinf, PCWSTR field, const void *arg)
79 {
80     INFCONTEXT context;
81     HRESULT hr = S_OK;
82     DWORD size;
83
84     BOOL ok = SetupFindFirstLineW(hinf, field, NULL, &context);
85     
86     for (; ok; ok = SetupFindNextLine(&context, &context))
87     {
88         WCHAR directory[MAX_INF_STRING_LENGTH];
89
90         if (!SetupGetLineTextW(&context, NULL, NULL, NULL, directory,
91                                MAX_INF_STRING_LENGTH, &size))
92             continue;
93
94         if (DelNodeW(directory, ADN_DEL_IF_EMPTY))
95             hr = E_FAIL;
96     }
97
98     return hr;
99 }
100
101 static HRESULT per_user_install_callback(HINF hinf, PCWSTR field, const void *arg)
102 {
103     PERUSERSECTIONW per_user;
104     INFCONTEXT context;
105     DWORD size;
106
107     static const WCHAR disp_name[] = {'D','i','s','p','l','a','y','N','a','m','e',0};
108     static const WCHAR version[] = {'V','e','r','s','i','o','n',0};
109     static const WCHAR is_installed[] = {'I','s','I','n','s','t','a','l','l','e','d',0};
110     static const WCHAR comp_id[] = {'C','o','m','p','o','n','e','n','t','I','D',0};
111     static const WCHAR guid[] = {'G','U','I','D',0};
112     static const WCHAR locale[] = {'L','o','c','a','l','e',0};
113     static const WCHAR stub_path[] = {'S','t','u','b','P','a','t','h',0};
114
115     per_user.bRollback = FALSE;
116     per_user.dwIsInstalled = 0;
117
118     SetupGetLineTextW(NULL, hinf, field, disp_name, per_user.szDispName,
119                      sizeof(per_user.szDispName) / sizeof(WCHAR), &size);
120
121     SetupGetLineTextW(NULL, hinf, field, version, per_user.szVersion,
122                      sizeof(per_user.szVersion) / sizeof(WCHAR), &size);
123
124     if (SetupFindFirstLineW(hinf, field, is_installed, &context))
125     {
126         SetupGetIntField(&context, 1, (PINT)&per_user.dwIsInstalled);
127     }
128
129     SetupGetLineTextW(NULL, hinf, field, comp_id, per_user.szCompID,
130                      sizeof(per_user.szCompID) / sizeof(WCHAR), &size);
131
132     SetupGetLineTextW(NULL, hinf, field, guid, per_user.szGUID,
133                      sizeof(per_user.szGUID) / sizeof(WCHAR), &size);
134
135     SetupGetLineTextW(NULL, hinf, field, locale, per_user.szLocale,
136                      sizeof(per_user.szLocale) / sizeof(WCHAR), &size);
137
138     SetupGetLineTextW(NULL, hinf, field, stub_path, per_user.szStub,
139                      sizeof(per_user.szStub) / sizeof(WCHAR), &size);
140
141     return SetPerUserSecValuesW(&per_user);
142 }
143
144 static HRESULT register_ocxs_callback(HINF hinf, PCWSTR field, const void *arg)
145 {
146     HMODULE hm;
147     INFCONTEXT context;
148     HRESULT hr = S_OK;
149
150     BOOL ok = SetupFindFirstLineW(hinf, field, NULL, &context);
151     
152     for (; ok; ok = SetupFindNextLine(&context, &context))
153     {
154         WCHAR buffer[MAX_INF_STRING_LENGTH];
155
156         /* get OCX filename */
157         if (!SetupGetStringFieldW(&context, 1, buffer,
158                                   sizeof(buffer) / sizeof(WCHAR), NULL))
159             continue;
160
161         hm = LoadLibraryExW(buffer, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
162         if (hm)
163         {
164             if (do_ocx_reg(hm, TRUE))
165                 hr = E_FAIL;
166
167             FreeLibrary(hm);
168         }
169         else
170             hr = E_FAIL;
171
172         if (FAILED(hr))
173         {
174             /* FIXME: display a message box */
175             break;
176         }
177     }
178
179     return hr;
180 }
181
182 static HRESULT run_setup_commands_callback(HINF hinf, PCWSTR field, const void *arg)
183 {
184     const ADVInfo *info = (const ADVInfo *)arg;
185     INFCONTEXT context;
186     HRESULT hr = S_OK;
187     DWORD size;
188
189     BOOL ok = SetupFindFirstLineW(hinf, field, NULL, &context);
190
191     for (; ok; ok = SetupFindNextLine(&context, &context))
192     {
193         WCHAR buffer[MAX_INF_STRING_LENGTH];
194
195         if (!SetupGetLineTextW(&context, NULL, NULL, NULL, buffer,
196                                MAX_INF_STRING_LENGTH, &size))
197             continue;
198
199         if (launch_exe(buffer, info->working_dir, NULL))
200             hr = E_FAIL;
201     }
202
203     return hr;
204 }
205
206 /* sequentially returns pointers to parameters in a parameter list
207  * returns NULL if the parameter is empty, e.g. one,,three  */
208 LPWSTR get_parameter(LPWSTR *params, WCHAR separator)
209 {
210     LPWSTR token = *params;
211
212     if (!*params)
213         return NULL;
214
215     *params = strchrW(*params, separator);
216     if (*params)
217         *(*params)++ = '\0';
218
219     if (!*token)
220         return NULL;
221
222     return token;
223 }
224
225 static BOOL is_full_path(LPCWSTR path)
226 {
227     const int MIN_PATH_LEN = 3;
228
229     if (!path || lstrlenW(path) < MIN_PATH_LEN)
230         return FALSE;
231
232     if ((path[1] == ':' && path[2] == '\\') || (path[0] == '\\' && path[1] == '\\'))
233         return TRUE;
234
235     return FALSE;
236 }
237
238 /* retrieves the contents of a field, dynamically growing the buffer if necessary */
239 static WCHAR *get_field_string(INFCONTEXT *context, DWORD index, WCHAR *buffer,
240                                const WCHAR *static_buffer, DWORD *size)
241 {
242     DWORD required;
243
244     if (SetupGetStringFieldW(context, index, buffer, *size, &required)) return buffer;
245
246     if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
247     {
248         /* now grow the buffer */
249         if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer);
250         if (!(buffer = HeapAlloc(GetProcessHeap(), 0, required*sizeof(WCHAR)))) return NULL;
251         *size = required;
252         if (SetupGetStringFieldW(context, index, buffer, *size, &required)) return buffer;
253     }
254
255     if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer);
256     return NULL;
257 }
258
259 /* iterates over all fields of a certain key of a certain section */
260 static HRESULT iterate_section_fields(HINF hinf, PCWSTR section, PCWSTR key,
261                                       iterate_fields_func callback, void *arg)
262 {
263     WCHAR static_buffer[200];
264     WCHAR *buffer = static_buffer;
265     DWORD size = sizeof(static_buffer) / sizeof(WCHAR);
266     INFCONTEXT context;
267     HRESULT hr = E_FAIL;
268
269     BOOL ok = SetupFindFirstLineW(hinf, section, key, &context);
270     while (ok)
271     {
272         UINT i, count = SetupGetFieldCount(&context);
273
274         for (i = 1; i <= count; i++)
275         {
276             if (!(buffer = get_field_string(&context, i, buffer, static_buffer, &size)))
277                 goto done;
278
279             if ((hr = callback(hinf, buffer, arg)) != S_OK)
280                 goto done;
281         }
282
283         ok = SetupFindNextMatchLineW(&context, key, &context);
284     }
285
286     hr = S_OK;
287
288  done:
289     if (buffer != static_buffer) HeapFree(GetProcessHeap(), 0, buffer);
290     return hr;
291 }
292
293 static HRESULT check_admin_rights(const ADVInfo *info)
294 {
295     INT check;
296     INFCONTEXT context;
297     HRESULT hr = S_OK;
298
299     if (!SetupFindFirstLineW(info->hinf, info->install_sec,
300                              CheckAdminRights, &context))
301         return S_OK;
302
303     if (!SetupGetIntField(&context, 1, &check))
304         return S_OK;
305
306     if (check == 1)
307         hr = IsNTAdmin(0, NULL) ? S_OK : E_FAIL;
308
309     return hr;
310 }
311
312 /* performs a setupapi-level install of the INF file */
313 static HRESULT spapi_install(const ADVInfo *info)
314 {
315     BOOL ret;
316     HRESULT res;
317     PVOID context;
318
319     context = SetupInitDefaultQueueCallbackEx(NULL, INVALID_HANDLE_VALUE, 0, 0, NULL);
320     if (!context)
321         return ADV_HRESULT(GetLastError());
322
323     ret = SetupInstallFromInfSectionW(NULL, info->hinf, info->install_sec,
324                                       SPINST_FILES, NULL, info->working_dir,
325                                       SP_COPY_NEWER, SetupDefaultQueueCallbackW,
326                                       context, NULL, NULL);
327     if (!ret)
328     {
329         res = ADV_HRESULT(GetLastError());
330         SetupTermDefaultQueueCallback(context);
331
332         return res;
333     }
334
335     SetupTermDefaultQueueCallback(context);
336
337     ret = SetupInstallFromInfSectionW(NULL, info->hinf, info->install_sec,
338                                       SPINST_INIFILES | SPINST_REGISTRY | SPINST_REGSVR,
339                                       HKEY_LOCAL_MACHINE, NULL, 0,
340                                       NULL, NULL, NULL, NULL);
341     if (!ret)
342         return ADV_HRESULT(GetLastError());
343
344     return S_OK;
345 }
346
347 /* processes the Advanced INF commands */
348 static HRESULT adv_install(ADVInfo *info)
349 {
350     HRESULT hr;
351
352     hr = check_admin_rights(info);
353     if (hr != S_OK)
354         return hr;
355
356     hr = iterate_section_fields(info->hinf, info->install_sec, RunPreSetupCommands,
357                                 run_setup_commands_callback, info);
358     if (hr != S_OK)
359         return hr;
360
361     OleInitialize(NULL);
362     hr = iterate_section_fields(info->hinf, info->install_sec,
363                                 RegisterOCXs, register_ocxs_callback, NULL);
364     OleUninitialize();
365     if (hr != S_OK)
366         return hr;
367
368     hr = iterate_section_fields(info->hinf, info->install_sec,
369                                 PerUserInstall, per_user_install_callback, info);
370     if (hr != S_OK)
371         return hr;
372
373     hr = iterate_section_fields(info->hinf, info->install_sec, RunPostSetupCommands,
374                                 run_setup_commands_callback, info);
375     if (hr != S_OK)
376         return hr;
377
378     hr = iterate_section_fields(info->hinf, info->install_sec,
379                                 DelDirs, del_dirs_callback, info);
380     if (hr != S_OK)
381         return hr;
382
383     return hr;
384 }
385
386 /* determines the proper working directory for the INF file */
387 static HRESULT get_working_dir(ADVInfo *info, LPCWSTR inf_filename, LPCWSTR working_dir)
388 {
389     WCHAR path[MAX_PATH];
390     LPCWSTR ptr;
391     DWORD len;
392
393     static const WCHAR backslash[] = {'\\',0};
394     static const WCHAR inf_dir[] = {'\\','I','N','F',0};
395
396     if ((ptr = strrchrW(inf_filename, '\\')))
397     {
398         len = ptr - inf_filename + 1;
399         ptr = inf_filename;
400     }
401     else if (working_dir && *working_dir)
402     {
403         len = lstrlenW(working_dir) + 1;
404         ptr = working_dir;
405     }
406     else
407     {
408         GetCurrentDirectoryW(MAX_PATH, path);
409         lstrcatW(path, backslash);
410         lstrcatW(path, inf_filename);
411
412         /* check if the INF file is in the current directory */
413         if (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
414         {
415             GetCurrentDirectoryW(MAX_PATH, path);
416         }
417         else
418         {
419             /* default to the windows\inf directory if all else fails */
420             GetWindowsDirectoryW(path, MAX_PATH);
421             lstrcatW(path, inf_dir);
422         }
423
424         len = lstrlenW(path) + 1;
425         ptr = path;
426     }
427
428     info->working_dir = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
429     if (!info->working_dir)
430         return E_OUTOFMEMORY;
431
432     lstrcpynW(info->working_dir, ptr, len);
433
434     return S_OK;
435 }
436
437 /* loads the INF file and performs checks on it */
438 static HRESULT install_init(LPCWSTR inf_filename, LPCWSTR install_sec,
439                             LPCWSTR working_dir, DWORD flags, ADVInfo *info)
440 {
441     DWORD len;
442     HRESULT hr;
443     LPCWSTR ptr, path;
444
445     static const WCHAR backslash[] = {'\\',0};
446     static const WCHAR default_install[] = {
447         'D','e','f','a','u','l','t','I','n','s','t','a','l','l',0
448     };
449
450     if (!(ptr = strrchrW(inf_filename, '\\')))
451         ptr = inf_filename;
452
453     len = lstrlenW(ptr);
454
455     info->inf_filename = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
456     if (!info->inf_filename)
457         return E_OUTOFMEMORY;
458
459     lstrcpyW(info->inf_filename, ptr);
460
461     /* FIXME: determine the proper platform to install (NTx86, etc) */
462     if (!install_sec || !*install_sec)
463     {
464         len = sizeof(default_install) - 1;
465         ptr = default_install;
466     }
467     else
468     {
469         len = lstrlenW(install_sec);
470         ptr = install_sec;
471     }
472
473     info->install_sec = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
474     if (!info->install_sec)
475         return E_OUTOFMEMORY;
476
477     lstrcpyW(info->install_sec, ptr);
478
479     hr = get_working_dir(info, inf_filename, working_dir);
480     if (FAILED(hr))
481         return hr;
482
483     len = lstrlenW(info->working_dir) + lstrlenW(info->inf_filename) + 2;
484     info->inf_path = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
485     if (!info->inf_path)
486         return E_OUTOFMEMORY;
487
488     lstrcpyW(info->inf_path, info->working_dir);
489     lstrcatW(info->inf_path, backslash);
490     lstrcatW(info->inf_path, info->inf_filename);
491
492     /* RunSetupCommand opens unmodifed filename parameter */
493     if (flags & RSC_FLAG_INF)
494         path = inf_filename;
495     else
496         path = info->inf_path;
497
498     info->hinf = SetupOpenInfFileW(path, NULL, INF_STYLE_WIN4, NULL);
499     if (info->hinf == INVALID_HANDLE_VALUE)
500         return ADV_HRESULT(GetLastError());
501
502     set_ldids(info->hinf, info->install_sec, info->working_dir);
503
504     /* FIXME: check that the INF is advanced */
505
506     info->flags = flags;
507     info->need_reboot = FALSE;
508
509     return S_OK;
510 }
511
512 /* release the install instance information */
513 static void install_release(const ADVInfo *info)
514 {
515     SetupCloseInfFile(info->hinf);
516
517     HeapFree(GetProcessHeap(), 0, info->inf_path);
518     HeapFree(GetProcessHeap(), 0, info->inf_filename);
519     HeapFree(GetProcessHeap(), 0, info->install_sec);
520     HeapFree(GetProcessHeap(), 0, info->working_dir);
521 }
522
523 /* this structure very closely resembles parameters of RunSetupCommand() */
524 typedef struct
525 {
526     HWND hwnd;
527     LPCSTR title;
528     LPCSTR inf_name;
529     LPCSTR dir;
530     LPCSTR section_name;
531 } SETUPCOMMAND_PARAMS;
532
533 typedef struct
534 {
535     HWND hwnd;
536     LPCWSTR title;
537     LPCWSTR inf_name;
538     LPCWSTR dir;
539     LPCWSTR section_name;
540 } SETUPCOMMAND_PARAMSW;
541
542 /* internal: see DoInfInstall */
543 static HRESULT DoInfInstallW(const SETUPCOMMAND_PARAMSW *setup)
544 {
545     ADVInfo info;
546     HRESULT hr;
547
548     TRACE("(%p)\n", setup);
549
550     ZeroMemory(&info, sizeof(ADVInfo));
551
552     hr = install_init(setup->inf_name, setup->section_name, setup->dir, 0, &info);
553     if (hr != S_OK)
554         goto done;
555
556     hr = spapi_install(&info);
557     if (hr != S_OK)
558         goto done;
559
560     hr = adv_install(&info);
561
562 done:
563     install_release(&info);
564
565     return S_OK;
566 }
567
568 /***********************************************************************
569  *      DoInfInstall  (ADVPACK.@)
570  *
571  * Install an INF section.
572  *
573  * PARAMS
574  *  setup [I] Structure containing install information.
575  *
576  * RETURNS
577  *   S_OK                                Everything OK
578  *   HRESULT_FROM_WIN32(GetLastError())  Some other error
579  */
580 HRESULT WINAPI DoInfInstall(const SETUPCOMMAND_PARAMS *setup)
581 {
582     UNICODE_STRING title, inf, section, dir;
583     SETUPCOMMAND_PARAMSW params;
584     HRESULT hr;
585
586     if (!setup)
587         return E_INVALIDARG;
588
589     RtlCreateUnicodeStringFromAsciiz(&title, setup->title);
590     RtlCreateUnicodeStringFromAsciiz(&inf, setup->inf_name);
591     RtlCreateUnicodeStringFromAsciiz(&section, setup->section_name);
592     RtlCreateUnicodeStringFromAsciiz(&dir, setup->dir);
593
594     params.title = title.Buffer;
595     params.inf_name = inf.Buffer;
596     params.section_name = section.Buffer;
597     params.dir = dir.Buffer;
598     params.hwnd = setup->hwnd;
599
600     hr = DoInfInstallW(&params);
601
602     RtlFreeUnicodeString(&title);
603     RtlFreeUnicodeString(&inf);
604     RtlFreeUnicodeString(&section);
605     RtlFreeUnicodeString(&dir);
606
607     return hr;
608 }
609
610 /***********************************************************************
611  *             ExecuteCabA    (ADVPACK.@)
612  *
613  * See ExecuteCabW.
614  */
615 HRESULT WINAPI ExecuteCabA(HWND hwnd, CABINFOA* pCab, LPVOID pReserved)
616 {
617     UNICODE_STRING cab, inf, section;
618     CABINFOW cabinfo;
619     HRESULT hr;
620
621     TRACE("(%p, %p, %p)\n", hwnd, pCab, pReserved);
622
623     if (!pCab)
624         return E_INVALIDARG;
625
626     if (pCab->pszCab)
627     {
628         RtlCreateUnicodeStringFromAsciiz(&cab, pCab->pszCab);
629         cabinfo.pszCab = cab.Buffer;
630     }
631     else
632         cabinfo.pszCab = NULL;
633
634     RtlCreateUnicodeStringFromAsciiz(&inf, pCab->pszInf);
635     RtlCreateUnicodeStringFromAsciiz(&section, pCab->pszSection);
636     
637     MultiByteToWideChar(CP_ACP, 0, pCab->szSrcPath, -1, cabinfo.szSrcPath,
638                         sizeof(cabinfo.szSrcPath) / sizeof(WCHAR));
639
640     cabinfo.pszInf = inf.Buffer;
641     cabinfo.pszSection = section.Buffer;
642     cabinfo.dwFlags = pCab->dwFlags;
643
644     hr = ExecuteCabW(hwnd, &cabinfo, pReserved);
645
646     if (pCab->pszCab)
647         RtlFreeUnicodeString(&cab);
648
649     RtlFreeUnicodeString(&inf);
650     RtlFreeUnicodeString(&section);
651
652     return hr;
653 }
654
655 /***********************************************************************
656  *             ExecuteCabW    (ADVPACK.@)
657  * 
658  * Installs the INF file extracted from a specified cabinet file.
659  * 
660  * PARAMS
661  *   hwnd      [I] Handle to the window used for the display.
662  *   pCab      [I] Information about the cabinet file.
663  *   pReserved [I] Reserved.  Must be NULL.
664  * 
665  * RETURNS
666  *   Success: S_OK.
667  *   Failure: E_FAIL.
668  */
669 HRESULT WINAPI ExecuteCabW(HWND hwnd, CABINFOW* pCab, LPVOID pReserved)
670 {
671     ADVInfo info;
672     HRESULT hr;
673
674     TRACE("(%p, %p, %p)\n", hwnd, pCab, pReserved);
675
676     ZeroMemory(&info, sizeof(ADVInfo));
677
678     if (pCab->pszCab && *pCab->pszCab)
679         FIXME("Cab archive not extracted!\n");
680
681     hr = install_init(pCab->pszInf, pCab->pszSection, pCab->szSrcPath, pCab->dwFlags, &info);
682     if (hr != S_OK)
683         goto done;
684
685     hr = spapi_install(&info);
686     if (hr != S_OK)
687         goto done;
688
689     hr = adv_install(&info);
690
691 done:
692     install_release(&info);
693
694     return hr;
695 }
696
697 /***********************************************************************
698  *      LaunchINFSectionA   (ADVPACK.@)
699  *
700  * See LaunchINFSectionW.
701  */
702 INT WINAPI LaunchINFSectionA(HWND hWnd, HINSTANCE hInst, LPSTR cmdline, INT show)
703 {
704     UNICODE_STRING cmd;
705     HRESULT hr;
706
707     TRACE("(%p, %p, %s, %i)\n", hWnd, hInst, debugstr_a(cmdline), show);
708
709     if (!cmdline)
710         return ADV_FAILURE;
711
712     RtlCreateUnicodeStringFromAsciiz(&cmd, cmdline);
713
714     hr = LaunchINFSectionW(hWnd, hInst, cmd.Buffer, show);
715
716     RtlFreeUnicodeString(&cmd);
717
718     return hr;
719 }
720
721 /***********************************************************************
722  *      LaunchINFSectionW   (ADVPACK.@)
723  *
724  * Installs an INF section without BACKUP/ROLLBACK capabilities.
725  *
726  * PARAMS
727  *   hWnd    [I] Handle to parent window, NULL for desktop.
728  *   hInst   [I] Instance of the process.
729  *   cmdline [I] Contains parameters in the order INF,section,flags,reboot.
730  *   show    [I] How the window should be shown.
731  *
732  * RETURNS
733  *  Success: ADV_SUCCESS.
734  *  Failure: ADV_FAILURE.
735  *
736  * NOTES
737  *  INF - Filename of the INF to launch.
738  *  section - INF section to install.
739  *  flags - see advpub.h.
740  *  reboot - smart reboot behavior
741  *    'A' Always reboot.
742  *    'I' Reboot if needed (default).
743  *    'N' No reboot.
744  */
745 INT WINAPI LaunchINFSectionW(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT show)
746 {
747     ADVInfo info;
748     LPWSTR cmdline_copy, cmdline_ptr;
749     LPWSTR inf_filename, install_sec;
750     LPWSTR str_flags;
751     DWORD flags = 0;
752     HRESULT hr = S_OK;
753
754     TRACE("(%p, %p, %s, %d)\n", hWnd, hInst, debugstr_w(cmdline), show);
755
756     if (!cmdline)
757         return ADV_FAILURE;
758
759     cmdline_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
760     cmdline_ptr = cmdline_copy;
761     lstrcpyW(cmdline_copy, cmdline);
762
763     inf_filename = get_parameter(&cmdline_ptr, ',');
764     install_sec = get_parameter(&cmdline_ptr, ',');
765
766     str_flags = get_parameter(&cmdline_ptr, ',');
767     if (str_flags)
768         flags = atolW(str_flags);
769
770     ZeroMemory(&info, sizeof(ADVInfo));
771
772     hr = install_init(inf_filename, install_sec, NULL, flags, &info);
773     if (hr != S_OK)
774         goto done;
775
776     hr = spapi_install(&info);
777     if (hr != S_OK)
778         goto done;
779
780     hr = adv_install(&info);
781
782 done:
783     install_release(&info);
784     HeapFree(GetProcessHeap(), 0, cmdline_copy);
785
786     return SUCCEEDED(hr) ? ADV_SUCCESS : ADV_FAILURE;
787 }
788
789 /***********************************************************************
790  *      LaunchINFSectionExA (ADVPACK.@)
791  *
792  * See LaunchINFSectionExW.
793  */
794 HRESULT WINAPI LaunchINFSectionExA(HWND hWnd, HINSTANCE hInst, LPSTR cmdline, INT show)
795 {
796     UNICODE_STRING cmd;
797     HRESULT hr;
798
799     TRACE("(%p, %p, %s, %i)\n", hWnd, hInst, debugstr_a(cmdline), show);
800
801     if (!cmdline)
802         return ADV_FAILURE;
803
804     RtlCreateUnicodeStringFromAsciiz(&cmd, cmdline);
805
806     hr = LaunchINFSectionExW(hWnd, hInst, cmd.Buffer, show);
807
808     RtlFreeUnicodeString(&cmd);
809
810     return hr;
811 }
812
813 /***********************************************************************
814  *      LaunchINFSectionExW (ADVPACK.@)
815  *
816  * Installs an INF section with BACKUP/ROLLBACK capabilities.
817  *
818  * PARAMS
819  *   hWnd    [I] Handle to parent window, NULL for desktop.
820  *   hInst   [I] Instance of the process.
821  *   cmdline [I] Contains parameters in the order INF,section,CAB,flags,reboot.
822  *   show    [I] How the window should be shown.
823  *
824  * RETURNS
825  *  Success: ADV_SUCCESS.
826  *  Failure: ADV_FAILURE.
827  *
828  * NOTES
829  *  INF - Filename of the INF to launch.
830  *  section - INF section to install.
831  *  flags - see advpub.h.
832  *  reboot - smart reboot behavior
833  *    'A' Always reboot.
834  *    'I' Reboot if needed (default).
835  *    'N' No reboot.
836  *
837  * BUGS
838  *  Doesn't handle the reboot flag.
839  */
840 HRESULT WINAPI LaunchINFSectionExW(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT show)
841 {
842     LPWSTR cmdline_copy, cmdline_ptr;
843     LPWSTR flags, ptr;
844     CABINFOW cabinfo;
845     HRESULT hr;
846
847     TRACE("(%p, %p, %s, %d)\n", hWnd, hInst, debugstr_w(cmdline), show);
848
849     if (!cmdline)
850         return ADV_FAILURE;
851
852     cmdline_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
853     cmdline_ptr = cmdline_copy;
854     lstrcpyW(cmdline_copy, cmdline);
855
856     cabinfo.pszInf = get_parameter(&cmdline_ptr, ',');
857     cabinfo.pszSection = get_parameter(&cmdline_ptr, ',');
858     cabinfo.pszCab = get_parameter(&cmdline_ptr, ',');
859     *cabinfo.szSrcPath = '\0';
860
861     flags = get_parameter(&cmdline_ptr, ',');
862     if (flags)
863         cabinfo.dwFlags = atolW(flags);
864
865     if (!is_full_path(cabinfo.pszCab) && !is_full_path(cabinfo.pszInf))
866     {
867         HeapFree(GetProcessHeap(), 0, cmdline_copy);
868         return E_INVALIDARG;
869     }
870
871     /* get the source path from the cab filename */
872     if (cabinfo.pszCab && *cabinfo.pszCab)
873     {
874         if (!is_full_path(cabinfo.pszCab))
875             lstrcpyW(cabinfo.szSrcPath, cabinfo.pszInf);
876         else
877             lstrcpyW(cabinfo.szSrcPath, cabinfo.pszCab);
878
879         ptr = strrchrW(cabinfo.szSrcPath, '\\');
880         *(++ptr) = '\0';
881     }
882
883     hr = ExecuteCabW(hWnd, &cabinfo, NULL);
884     HeapFree(GetProcessHeap(), 0, cmdline_copy);
885     return SUCCEEDED(hr) ? ADV_SUCCESS : ADV_FAILURE;
886 }
887
888 HRESULT launch_exe(LPCWSTR cmd, LPCWSTR dir, HANDLE *phEXE)
889 {
890     STARTUPINFOW si;
891     PROCESS_INFORMATION pi;
892
893     if (phEXE) *phEXE = NULL;
894
895     ZeroMemory(&pi, sizeof(pi));
896     ZeroMemory(&si, sizeof(si));
897     si.cb = sizeof(si);
898
899     if (!CreateProcessW(NULL, (LPWSTR)cmd, NULL, NULL, FALSE,
900                         CREATE_DEFAULT_ERROR_MODE | CREATE_NEW_PROCESS_GROUP,
901                         NULL, dir, &si, &pi))
902     {
903         return HRESULT_FROM_WIN32(GetLastError());
904     }
905
906     CloseHandle(pi.hThread);
907
908     if (phEXE)
909     {
910         *phEXE = pi.hProcess;
911         return S_ASYNCHRONOUS;
912     }
913
914     /* wait for the child process to finish */
915     WaitForSingleObject(pi.hProcess, INFINITE);
916     CloseHandle(pi.hProcess);
917
918     return S_OK;
919 }
920
921 /***********************************************************************
922  *      RunSetupCommandA  (ADVPACK.@)
923  *
924  * See RunSetupCommandW.
925  */
926 HRESULT WINAPI RunSetupCommandA(HWND hWnd, LPCSTR szCmdName,
927                                 LPCSTR szInfSection, LPCSTR szDir,
928                                 LPCSTR lpszTitle, HANDLE *phEXE,
929                                 DWORD dwFlags, LPVOID pvReserved)
930 {
931     UNICODE_STRING cmdname, infsec;
932     UNICODE_STRING dir, title;
933     HRESULT hr;
934
935     TRACE("(%p, %s, %s, %s, %s, %p, %d, %p)\n",
936           hWnd, debugstr_a(szCmdName), debugstr_a(szInfSection),
937           debugstr_a(szDir), debugstr_a(lpszTitle),
938           phEXE, dwFlags, pvReserved);
939
940     if (!szCmdName || !szDir)
941         return E_INVALIDARG;
942
943     RtlCreateUnicodeStringFromAsciiz(&cmdname, szCmdName);
944     RtlCreateUnicodeStringFromAsciiz(&infsec, szInfSection);
945     RtlCreateUnicodeStringFromAsciiz(&dir, szDir);
946     RtlCreateUnicodeStringFromAsciiz(&title, lpszTitle);
947
948     hr = RunSetupCommandW(hWnd, cmdname.Buffer, infsec.Buffer, dir.Buffer,
949                           title.Buffer, phEXE, dwFlags, pvReserved);
950
951     RtlFreeUnicodeString(&cmdname);
952     RtlFreeUnicodeString(&infsec);
953     RtlFreeUnicodeString(&dir);
954     RtlFreeUnicodeString(&title);
955
956     return hr;
957 }
958
959 /***********************************************************************
960  *      RunSetupCommandW  (ADVPACK.@)
961  *
962  * Executes an install section in an INF file or a program.
963  *
964  * PARAMS
965  *   hWnd          [I] Handle to parent window, NULL for quiet mode
966  *   szCmdName     [I] Inf or EXE filename to execute
967  *   szInfSection  [I] Inf section to install, NULL for DefaultInstall
968  *   szDir         [I] Path to extracted files
969  *   szTitle       [I] Title of all dialogs
970  *   phEXE         [O] Handle of EXE to wait for
971  *   dwFlags       [I] Flags; see include/advpub.h
972  *   pvReserved    [I] Reserved
973  *
974  * RETURNS
975  *   S_OK                                 Everything OK
976  *   S_ASYNCHRONOUS                       OK, required to wait on phEXE
977  *   ERROR_SUCCESS_REBOOT_REQUIRED        Reboot required
978  *   E_INVALIDARG                         Invalid argument given
979  *   HRESULT_FROM_WIN32(ERROR_OLD_WIN_VERSION)
980  *                                        Not supported on this Windows version
981  *   E_UNEXPECTED                         Unexpected error
982  *   HRESULT_FROM_WIN32(GetLastError())   Some other error
983  */
984 HRESULT WINAPI RunSetupCommandW(HWND hWnd, LPCWSTR szCmdName,
985                                 LPCWSTR szInfSection, LPCWSTR szDir,
986                                 LPCWSTR lpszTitle, HANDLE *phEXE,
987                                 DWORD dwFlags, LPVOID pvReserved)
988 {
989     ADVInfo info;
990     HRESULT hr;
991
992     TRACE("(%p, %s, %s, %s, %s, %p, %d, %p)\n",
993           hWnd, debugstr_w(szCmdName), debugstr_w(szInfSection),
994           debugstr_w(szDir), debugstr_w(lpszTitle),
995           phEXE, dwFlags, pvReserved);
996
997     if (dwFlags & RSC_FLAG_UPDHLPDLLS)
998         FIXME("Unhandled flag: RSC_FLAG_UPDHLPDLLS\n");
999
1000     if (!szCmdName || !szDir)
1001         return E_INVALIDARG;
1002
1003     if (!(dwFlags & RSC_FLAG_INF))
1004         return launch_exe(szCmdName, szDir, phEXE);
1005
1006     ZeroMemory(&info, sizeof(ADVInfo));
1007
1008     hr = install_init(szCmdName, szInfSection, szDir, dwFlags, &info);
1009     if (hr != S_OK)
1010         goto done;
1011
1012     hr = spapi_install(&info);
1013     if (hr != S_OK)
1014         goto done;
1015
1016     hr = adv_install(&info);
1017
1018 done:
1019     install_release(&info);
1020
1021     return hr;
1022 }