?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 9eb9af089d68d39110a91889d3a673043db63c4b
[wine/hacks.git] / dlls / msi / msi.c
blob2b3b635390d43a6fbe1e8f62e99a8963c7215614
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
3 *
4 * Copyright 2002,2003,2004,2005 Mike McCormack 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 #define COBJMACROS
24 #define NONAMELESSUNION
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winreg.h"
29 #include "winnls.h"
30 #include "shlwapi.h"
31 #include "wine/debug.h"
32 #include "msi.h"
33 #include "msidefs.h"
34 #include "msiquery.h"
35 #include "msipriv.h"
36 #include "wincrypt.h"
37 #include "winver.h"
38 #include "winuser.h"
39 #include "shlobj.h"
40 #include "shobjidl.h"
41 #include "objidl.h"
42 #include "wine/unicode.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(msi);
45
46 static const WCHAR installerW[] = {'\\','I','n','s','t','a','l','l','e','r',0};
47
48 static UINT msi_locate_product(LPCWSTR szProduct, MSIINSTALLCONTEXT *context)
49 {
50 HKEY hkey = NULL;
51
52 *context = MSIINSTALLCONTEXT_NONE;
53
54 if (MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_USERMANAGED,
55 &hkey, FALSE) == ERROR_SUCCESS)
56 *context = MSIINSTALLCONTEXT_USERMANAGED;
57 else if (MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_MACHINE,
58 &hkey, FALSE) == ERROR_SUCCESS)
59 *context = MSIINSTALLCONTEXT_MACHINE;
60 else if (MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
61 &hkey, FALSE) == ERROR_SUCCESS)
62 *context = MSIINSTALLCONTEXT_USERUNMANAGED;
63
64 RegCloseKey(hkey);
65
66 if (*context == MSIINSTALLCONTEXT_NONE)
67 return ERROR_UNKNOWN_PRODUCT;
68
69 return ERROR_SUCCESS;
70 }
71
72 UINT WINAPI MsiOpenProductA(LPCSTR szProduct, MSIHANDLE *phProduct)
73 {
74 UINT r;
75 LPWSTR szwProd = NULL;
76
77 TRACE("%s %p\n",debugstr_a(szProduct), phProduct);
78
79 if( szProduct )
80 {
81 szwProd = strdupAtoW( szProduct );
82 if( !szwProd )
83 return ERROR_OUTOFMEMORY;
84 }
85
86 r = MsiOpenProductW( szwProd, phProduct );
87
88 msi_free( szwProd );
89
90 return r;
91 }
92
93 static UINT MSI_OpenProductW(LPCWSTR szProduct, MSIPACKAGE **package)
94 {
95 UINT r;
96 HKEY props;
97 LPWSTR path;
98 MSIINSTALLCONTEXT context;
99
100 static const WCHAR managed[] = {
101 'M','a','n','a','g','e','d','L','o','c','a','l','P','a','c','k','a','g','e',0};
102 static const WCHAR local[] = {'L','o','c','a','l','P','a','c','k','a','g','e',0};
103
104 TRACE("%s %p\n", debugstr_w(szProduct), package);
105
106 r = msi_locate_product(szProduct, &context);
107 if (r != ERROR_SUCCESS)
108 return r;
109
110 if (context == MSIINSTALLCONTEXT_MACHINE)
111 r = MSIREG_OpenLocalSystemInstallProps(szProduct, &props, FALSE);
112 else if (context == MSIINSTALLCONTEXT_USERMANAGED ||
113 context == MSIINSTALLCONTEXT_USERUNMANAGED)
114 r = MSIREG_OpenCurrentUserInstallProps(szProduct, &props, FALSE);
115
116 if (r != ERROR_SUCCESS)
117 return ERROR_UNKNOWN_PRODUCT;
118
119 if (context == MSIINSTALLCONTEXT_USERMANAGED)
120 path = msi_reg_get_val_str(props, managed);
121 else
122 path = msi_reg_get_val_str(props, local);
123
124 r = ERROR_UNKNOWN_PRODUCT;
125
126 if (!path || GetFileAttributesW(path) == INVALID_FILE_ATTRIBUTES)
127 goto done;
128
129 if (PathIsRelativeW(path))
130 {
131 r = ERROR_INSTALL_PACKAGE_OPEN_FAILED;
132 goto done;
133 }
134
135 r = MSI_OpenPackageW(path, package);
136
137 done:
138 RegCloseKey(props);
139 msi_free(path);
140 return r;
141 }
142
143 UINT WINAPI MsiOpenProductW(LPCWSTR szProduct, MSIHANDLE *phProduct)
144 {
145 MSIPACKAGE *package = NULL;
146 WCHAR squished_pc[GUID_SIZE];
147 UINT r;
148
149 if (!szProduct || !squash_guid(szProduct, squished_pc))
150 return ERROR_INVALID_PARAMETER;
151
152 if (!phProduct)
153 return ERROR_INVALID_PARAMETER;
154
155 r = MSI_OpenProductW(szProduct, &package);
156 if (r != ERROR_SUCCESS)
157 return r;
158
159 *phProduct = alloc_msihandle(&package->hdr);
160 if (!*phProduct)
161 r = ERROR_NOT_ENOUGH_MEMORY;
162
163 msiobj_release(&package->hdr);
164 return r;
165 }
166
167 UINT WINAPI MsiAdvertiseProductA(LPCSTR szPackagePath, LPCSTR szScriptfilePath,
168 LPCSTR szTransforms, LANGID lgidLanguage)
169 {
170 FIXME("%s %s %s %08x\n",debugstr_a(szPackagePath),
171 debugstr_a(szScriptfilePath), debugstr_a(szTransforms), lgidLanguage);
172 return ERROR_CALL_NOT_IMPLEMENTED;
173 }
174
175 UINT WINAPI MsiAdvertiseProductW(LPCWSTR szPackagePath, LPCWSTR szScriptfilePath,
176 LPCWSTR szTransforms, LANGID lgidLanguage)
177 {
178 FIXME("%s %s %s %08x\n",debugstr_w(szPackagePath),
179 debugstr_w(szScriptfilePath), debugstr_w(szTransforms), lgidLanguage);
180 return ERROR_CALL_NOT_IMPLEMENTED;
181 }
182
183 UINT WINAPI MsiAdvertiseProductExA(LPCSTR szPackagePath, LPCSTR szScriptfilePath,
184 LPCSTR szTransforms, LANGID lgidLanguage, DWORD dwPlatform, DWORD dwOptions)
185 {
186 FIXME("%s %s %s %08x %08x %08x\n", debugstr_a(szPackagePath),
187 debugstr_a(szScriptfilePath), debugstr_a(szTransforms),
188 lgidLanguage, dwPlatform, dwOptions);
189 return ERROR_CALL_NOT_IMPLEMENTED;
190 }
191
192 UINT WINAPI MsiAdvertiseProductExW( LPCWSTR szPackagePath, LPCWSTR szScriptfilePath,
193 LPCWSTR szTransforms, LANGID lgidLanguage, DWORD dwPlatform, DWORD dwOptions)
194 {
195 FIXME("%s %s %s %08x %08x %08x\n", debugstr_w(szPackagePath),
196 debugstr_w(szScriptfilePath), debugstr_w(szTransforms),
197 lgidLanguage, dwPlatform, dwOptions);
198 return ERROR_CALL_NOT_IMPLEMENTED;
199 }
200
201 UINT WINAPI MsiInstallProductA(LPCSTR szPackagePath, LPCSTR szCommandLine)
202 {
203 LPWSTR szwPath = NULL, szwCommand = NULL;
204 UINT r = ERROR_OUTOFMEMORY;
205
206 TRACE("%s %s\n",debugstr_a(szPackagePath), debugstr_a(szCommandLine));
207
208 if( szPackagePath )
209 {
210 szwPath = strdupAtoW( szPackagePath );
211 if( !szwPath )
212 goto end;
213 }
214
215 if( szCommandLine )
216 {
217 szwCommand = strdupAtoW( szCommandLine );
218 if( !szwCommand )
219 goto end;
220 }
221
222 r = MsiInstallProductW( szwPath, szwCommand );
223
224 end:
225 msi_free( szwPath );
226 msi_free( szwCommand );
227
228 return r;
229 }
230
231 UINT WINAPI MsiInstallProductW(LPCWSTR szPackagePath, LPCWSTR szCommandLine)
232 {
233 MSIPACKAGE *package = NULL;
234 UINT r;
235
236 TRACE("%s %s\n",debugstr_w(szPackagePath), debugstr_w(szCommandLine));
237
238 r = MSI_OpenPackageW( szPackagePath, &package );
239 if (r == ERROR_SUCCESS)
240 {
241 r = MSI_InstallPackage( package, szPackagePath, szCommandLine );
242 msiobj_release( &package->hdr );
243 }
244
245 return r;
246 }
247
248 UINT WINAPI MsiReinstallProductA(LPCSTR szProduct, DWORD dwReinstallMode)
249 {
250 FIXME("%s %08x\n", debugstr_a(szProduct), dwReinstallMode);
251 return ERROR_CALL_NOT_IMPLEMENTED;
252 }
253
254 UINT WINAPI MsiReinstallProductW(LPCWSTR szProduct, DWORD dwReinstallMode)
255 {
256 FIXME("%s %08x\n", debugstr_w(szProduct), dwReinstallMode);
257 return ERROR_CALL_NOT_IMPLEMENTED;
258 }
259
260 UINT WINAPI MsiApplyPatchA(LPCSTR szPatchPackage, LPCSTR szInstallPackage,
261 INSTALLTYPE eInstallType, LPCSTR szCommandLine)
262 {
263 LPWSTR patch_package = NULL;
264 LPWSTR install_package = NULL;
265 LPWSTR command_line = NULL;
266 UINT r = ERROR_OUTOFMEMORY;
267
268 TRACE("%s %s %d %s\n", debugstr_a(szPatchPackage), debugstr_a(szInstallPackage),
269 eInstallType, debugstr_a(szCommandLine));
270
271 if (szPatchPackage && !(patch_package = strdupAtoW(szPatchPackage)))
272 goto done;
273
274 if (szInstallPackage && !(install_package = strdupAtoW(szInstallPackage)))
275 goto done;
276
277 if (szCommandLine && !(command_line = strdupAtoW(szCommandLine)))
278 goto done;
279
280 r = MsiApplyPatchW(patch_package, install_package, eInstallType, command_line);
281
282 done:
283 msi_free(patch_package);
284 msi_free(install_package);
285 msi_free(command_line);
286
287 return r;
288 }
289
290 UINT WINAPI MsiApplyPatchW(LPCWSTR szPatchPackage, LPCWSTR szInstallPackage,
291 INSTALLTYPE eInstallType, LPCWSTR szCommandLine)
292 {
293 MSIHANDLE patch, info;
294 UINT r, type;
295 DWORD size = 0;
296 LPCWSTR cmd_ptr = szCommandLine;
297 LPWSTR beg, end;
298 LPWSTR cmd = NULL, codes = NULL;
299
300 static const WCHAR space[] = {' ',0};
301 static const WCHAR patcheq[] = {'P','A','T','C','H','=',0};
302 static WCHAR empty[] = {0};
303
304 TRACE("%s %s %d %s\n", debugstr_w(szPatchPackage), debugstr_w(szInstallPackage),
305 eInstallType, debugstr_w(szCommandLine));
306
307 if (szInstallPackage || eInstallType == INSTALLTYPE_NETWORK_IMAGE ||
308 eInstallType == INSTALLTYPE_SINGLE_INSTANCE)
309 {
310 FIXME("Only reading target products from patch\n");
311 return ERROR_CALL_NOT_IMPLEMENTED;
312 }
313
314 r = MsiOpenDatabaseW(szPatchPackage, MSIDBOPEN_READONLY, &patch);
315 if (r != ERROR_SUCCESS)
316 return r;
317
318 r = MsiGetSummaryInformationW(patch, NULL, 0, &info);
319 if (r != ERROR_SUCCESS)
320 goto done;
321
322 r = MsiSummaryInfoGetPropertyW(info, PID_TEMPLATE, &type, NULL, NULL, empty, &size);
323 if (r != ERROR_MORE_DATA || !size || type != VT_LPSTR)
324 {
325 ERR("Failed to read product codes from patch\n");
326 goto done;
327 }
328
329 codes = msi_alloc(++size * sizeof(WCHAR));
330 if (!codes)
331 {
332 r = ERROR_OUTOFMEMORY;
333 goto done;
334 }
335
336 r = MsiSummaryInfoGetPropertyW(info, PID_TEMPLATE, &type, NULL, NULL, codes, &size);
337 if (r != ERROR_SUCCESS)
338 goto done;
339
340 if (!szCommandLine)
341 cmd_ptr = empty;
342
343 size = lstrlenW(cmd_ptr) + lstrlenW(patcheq) + lstrlenW(szPatchPackage) + 1;
344 cmd = msi_alloc(size * sizeof(WCHAR));
345 if (!cmd)
346 {
347 r = ERROR_OUTOFMEMORY;
348 goto done;
349 }
350
351 lstrcpyW(cmd, cmd_ptr);
352 if (szCommandLine) lstrcatW(cmd, space);
353 lstrcatW(cmd, patcheq);
354 lstrcatW(cmd, szPatchPackage);
355
356 beg = codes;
357 while ((end = strchrW(beg, '}')))
358 {
359 *(end + 1) = '\0';
360
361 r = MsiConfigureProductExW(beg, INSTALLLEVEL_DEFAULT, INSTALLSTATE_DEFAULT, cmd);
362 if (r != ERROR_SUCCESS)
363 goto done;
364
365 beg = end + 2;
366 }
367
368 done:
369 msi_free(cmd);
370 msi_free(codes);
371
372 MsiCloseHandle(info);
373 MsiCloseHandle(patch);
374
375 return r;
376 }
377
378 UINT WINAPI MsiDetermineApplicablePatchesA(LPCSTR szProductPackagePath,
379 DWORD cPatchInfo, PMSIPATCHSEQUENCEINFOA pPatchInfo)
380 {
381 FIXME("(%s, %d, %p): stub!\n", debugstr_a(szProductPackagePath),
382 cPatchInfo, pPatchInfo);
383
384 return ERROR_CALL_NOT_IMPLEMENTED;
385 }
386
387 UINT WINAPI MsiDetermineApplicablePatchesW(LPCWSTR szProductPackagePath,
388 DWORD cPatchInfo, PMSIPATCHSEQUENCEINFOW pPatchInfo)
389 {
390 FIXME("(%s, %d, %p): stub!\n", debugstr_w(szProductPackagePath),
391 cPatchInfo, pPatchInfo);
392
393 return ERROR_CALL_NOT_IMPLEMENTED;
394 }
395
396 static UINT msi_open_package(LPCWSTR product, MSIINSTALLCONTEXT context,
397 MSIPACKAGE **package)
398 {
399 UINT r;
400 DWORD sz;
401 HKEY props;
402 LPWSTR localpack;
403 WCHAR sourcepath[MAX_PATH];
404 WCHAR filename[MAX_PATH];
405
406 static const WCHAR szLocalPackage[] = {
407 'L','o','c','a','l','P','a','c','k','a','g','e',0};
408
409 if (context == MSIINSTALLCONTEXT_MACHINE)
410 r = MSIREG_OpenLocalSystemInstallProps(product, &props, FALSE);
411 else
412 r = MSIREG_OpenCurrentUserInstallProps(product, &props, FALSE);
413
414 if (r != ERROR_SUCCESS)
415 return ERROR_BAD_CONFIGURATION;
416
417 localpack = msi_reg_get_val_str(props, szLocalPackage);
418 if (localpack)
419 {
420 lstrcpyW(sourcepath, localpack);
421 msi_free(localpack);
422 }
423
424 if (!localpack || GetFileAttributesW(sourcepath) == INVALID_FILE_ATTRIBUTES)
425 {
426 sz = sizeof(sourcepath);
427 MsiSourceListGetInfoW(product, NULL, context, MSICODE_PRODUCT,
428 INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
429
430 sz = sizeof(filename);
431 MsiSourceListGetInfoW(product, NULL, context, MSICODE_PRODUCT,
432 INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
433
434 lstrcatW(sourcepath, filename);
435 }
436
437 if (GetFileAttributesW(sourcepath) == INVALID_FILE_ATTRIBUTES)
438 return ERROR_INSTALL_SOURCE_ABSENT;
439
440 return MSI_OpenPackageW(sourcepath, package);
441 }
442
443 UINT WINAPI MsiConfigureProductExW(LPCWSTR szProduct, int iInstallLevel,
444 INSTALLSTATE eInstallState, LPCWSTR szCommandLine)
445 {
446 MSIPACKAGE* package = NULL;
447 MSIINSTALLCONTEXT context;
448 UINT r;
449 DWORD sz;
450 WCHAR sourcepath[MAX_PATH];
451 LPWSTR commandline;
452
453 static const WCHAR szInstalled[] = {
454 ' ','I','n','s','t','a','l','l','e','d','=','1',0};
455 static const WCHAR szRemoveAll[] = {
456 ' ','R','E','M','O','V','E','=','A','L','L',0};
457 static const WCHAR szMachine[] = {
458 ' ','A','L','L','U','S','E','R','S','=','1',0};
459
460 TRACE("%s %d %d %s\n",debugstr_w(szProduct), iInstallLevel, eInstallState,
461 debugstr_w(szCommandLine));
462
463 if (!szProduct || lstrlenW(szProduct) != GUID_SIZE - 1)
464 return ERROR_INVALID_PARAMETER;
465
466 if (eInstallState == INSTALLSTATE_ADVERTISED ||
467 eInstallState == INSTALLSTATE_SOURCE)
468 {
469 FIXME("State %d not implemented\n", eInstallState);
470 return ERROR_CALL_NOT_IMPLEMENTED;
471 }
472
473 r = msi_locate_product(szProduct, &context);
474 if (r != ERROR_SUCCESS)
475 return r;
476
477 r = msi_open_package(szProduct, context, &package);
478 if (r != ERROR_SUCCESS)
479 return r;
480
481 sz = lstrlenW(szInstalled) + 1;
482
483 if (szCommandLine)
484 sz += lstrlenW(szCommandLine);
485
486 if (eInstallState == INSTALLSTATE_ABSENT)
487 sz += lstrlenW(szRemoveAll);
488
489 if (context == MSIINSTALLCONTEXT_MACHINE)
490 sz += lstrlenW(szMachine);
491
492 commandline = msi_alloc(sz * sizeof(WCHAR));
493 if (!commandline)
494 {
495 r = ERROR_OUTOFMEMORY;
496 goto end;
497 }
498
499 commandline[0] = 0;
500 if (szCommandLine)
501 lstrcpyW(commandline,szCommandLine);
502
503 if (MsiQueryProductStateW(szProduct) != INSTALLSTATE_UNKNOWN)
504 lstrcatW(commandline,szInstalled);
505
506 if (eInstallState == INSTALLSTATE_ABSENT)
507 lstrcatW(commandline, szRemoveAll);
508
509 if (context == MSIINSTALLCONTEXT_MACHINE)
510 lstrcatW(commandline, szMachine);
511
512 r = MSI_InstallPackage( package, sourcepath, commandline );
513
514 msi_free(commandline);
515
516 end:
517 msiobj_release( &package->hdr );
518
519 return r;
520 }
521
522 UINT WINAPI MsiConfigureProductExA(LPCSTR szProduct, int iInstallLevel,
523 INSTALLSTATE eInstallState, LPCSTR szCommandLine)
524 {
525 LPWSTR szwProduct = NULL;
526 LPWSTR szwCommandLine = NULL;
527 UINT r = ERROR_OUTOFMEMORY;
528
529 if( szProduct )
530 {
531 szwProduct = strdupAtoW( szProduct );
532 if( !szwProduct )
533 goto end;
534 }
535
536 if( szCommandLine)
537 {
538 szwCommandLine = strdupAtoW( szCommandLine );
539 if( !szwCommandLine)
540 goto end;
541 }
542
543 r = MsiConfigureProductExW( szwProduct, iInstallLevel, eInstallState,
544 szwCommandLine );
545 end:
546 msi_free( szwProduct );
547 msi_free( szwCommandLine);
548
549 return r;
550 }
551
552 UINT WINAPI MsiConfigureProductA(LPCSTR szProduct, int iInstallLevel,
553 INSTALLSTATE eInstallState)
554 {
555 LPWSTR szwProduct = NULL;
556 UINT r;
557
558 TRACE("%s %d %d\n",debugstr_a(szProduct), iInstallLevel, eInstallState);
559
560 if( szProduct )
561 {
562 szwProduct = strdupAtoW( szProduct );
563 if( !szwProduct )
564 return ERROR_OUTOFMEMORY;
565 }
566
567 r = MsiConfigureProductW( szwProduct, iInstallLevel, eInstallState );
568 msi_free( szwProduct );
569
570 return r;
571 }
572
573 UINT WINAPI MsiConfigureProductW(LPCWSTR szProduct, int iInstallLevel,
574 INSTALLSTATE eInstallState)
575 {
576 return MsiConfigureProductExW(szProduct, iInstallLevel, eInstallState, NULL);
577 }
578
579 UINT WINAPI MsiGetProductCodeA(LPCSTR szComponent, LPSTR szBuffer)
580 {
581 LPWSTR szwComponent = NULL;
582 UINT r;
583 WCHAR szwBuffer[GUID_SIZE];
584
585 TRACE("%s %s\n",debugstr_a(szComponent), debugstr_a(szBuffer));
586
587 if( szComponent )
588 {
589 szwComponent = strdupAtoW( szComponent );
590 if( !szwComponent )
591 return ERROR_OUTOFMEMORY;
592 }
593
594 *szwBuffer = '\0';
595 r = MsiGetProductCodeW( szwComponent, szwBuffer );
596
597 if(*szwBuffer)
598 WideCharToMultiByte(CP_ACP, 0, szwBuffer, -1, szBuffer, GUID_SIZE, NULL, NULL);
599
600 msi_free( szwComponent );
601
602 return r;
603 }
604
605 UINT WINAPI MsiGetProductCodeW(LPCWSTR szComponent, LPWSTR szBuffer)
606 {
607 UINT rc, index;
608 HKEY compkey, prodkey;
609 WCHAR squished_comp[GUID_SIZE];
610 WCHAR squished_prod[GUID_SIZE];
611 DWORD sz = GUID_SIZE;
612
613 TRACE("%s %p\n", debugstr_w(szComponent), szBuffer);
614
615 if (!szComponent || !*szComponent)
616 return ERROR_INVALID_PARAMETER;
617
618 if (!squash_guid(szComponent, squished_comp))
619 return ERROR_INVALID_PARAMETER;
620
621 if (MSIREG_OpenUserDataComponentKey(szComponent, &compkey, FALSE) != ERROR_SUCCESS &&
622 MSIREG_OpenLocalSystemComponentKey(szComponent, &compkey, FALSE) != ERROR_SUCCESS)
623 {
624 return ERROR_UNKNOWN_COMPONENT;
625 }
626
627 rc = RegEnumValueW(compkey, 0, squished_prod, &sz, NULL, NULL, NULL, NULL);
628 if (rc != ERROR_SUCCESS)
629 {
630 RegCloseKey(compkey);
631 return ERROR_UNKNOWN_COMPONENT;
632 }
633
634 /* check simple case, only one product */
635 rc = RegEnumValueW(compkey, 1, squished_prod, &sz, NULL, NULL, NULL, NULL);
636 if (rc == ERROR_NO_MORE_ITEMS)
637 {
638 rc = ERROR_SUCCESS;
639 goto done;
640 }
641
642 index = 0;
643 while ((rc = RegEnumValueW(compkey, index, squished_prod, &sz,
644 NULL, NULL, NULL, NULL)) != ERROR_NO_MORE_ITEMS)
645 {
646 index++;
647 sz = GUID_SIZE;
648 unsquash_guid(squished_prod, szBuffer);
649
650 if (MSIREG_OpenProductKey(szBuffer, MSIINSTALLCONTEXT_USERMANAGED,
651 &prodkey, FALSE) == ERROR_SUCCESS ||
652 MSIREG_OpenProductKey(szBuffer, MSIINSTALLCONTEXT_USERUNMANAGED,
653 &prodkey, FALSE) == ERROR_SUCCESS ||
654 MSIREG_OpenProductKey(szBuffer, MSIINSTALLCONTEXT_MACHINE,
655 &prodkey, FALSE) == ERROR_SUCCESS)
656 {
657 RegCloseKey(prodkey);
658 rc = ERROR_SUCCESS;
659 goto done;
660 }
661 }
662
663 rc = ERROR_INSTALL_FAILURE;
664
665 done:
666 RegCloseKey(compkey);
667 unsquash_guid(squished_prod, szBuffer);
668 return rc;
669 }
670
671 static LPWSTR msi_reg_get_value(HKEY hkey, LPCWSTR name, DWORD *type)
672 {
673 DWORD dval;
674 LONG res;
675 WCHAR temp[20];
676
677 static const WCHAR format[] = {'%','d',0};
678
679 res = RegQueryValueExW(hkey, name, NULL, type, NULL, NULL);
680 if (res != ERROR_SUCCESS)
681 return NULL;
682
683 if (*type == REG_SZ)
684 return msi_reg_get_val_str(hkey, name);
685
686 if (!msi_reg_get_val_dword(hkey, name, &dval))
687 return NULL;
688
689 sprintfW(temp, format, dval);
690 return strdupW(temp);
691 }
692
693 static UINT WINAPI MSI_GetProductInfo(LPCWSTR szProduct, LPCWSTR szAttribute,
694 awstring *szValue, LPDWORD pcchValueBuf)
695 {
696 UINT r = ERROR_UNKNOWN_PROPERTY;
697 HKEY prodkey, userdata, source;
698 LPWSTR val = NULL;
699 WCHAR squished_pc[GUID_SIZE];
700 WCHAR packagecode[GUID_SIZE];
701 BOOL classes = FALSE;
702 BOOL badconfig = FALSE;
703 LONG res;
704 DWORD save, type = REG_NONE;
705
706 static WCHAR empty[] = {0};
707 static const WCHAR sourcelist[] = {
708 'S','o','u','r','c','e','L','i','s','t',0};
709 static const WCHAR display_name[] = {
710 'D','i','s','p','l','a','y','N','a','m','e',0};
711 static const WCHAR display_version[] = {
712 'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0};
713 static const WCHAR assignment[] = {
714 'A','s','s','i','g','n','m','e','n','t',0};
715
716 TRACE("%s %s %p %p\n", debugstr_w(szProduct),
717 debugstr_w(szAttribute), szValue, pcchValueBuf);
718
719 if ((szValue->str.w && !pcchValueBuf) || !szProduct || !szAttribute)
720 return ERROR_INVALID_PARAMETER;
721
722 if (!squash_guid(szProduct, squished_pc))
723 return ERROR_INVALID_PARAMETER;
724
725 if ((r = MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_USERMANAGED,
726 &prodkey, FALSE)) != ERROR_SUCCESS &&
727 (r = MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
728 &prodkey, FALSE)) != ERROR_SUCCESS &&
729 (r = MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_MACHINE,
730 &prodkey, FALSE)) == ERROR_SUCCESS)
731 {
732 classes = TRUE;
733 }
734
735 if (classes)
736 MSIREG_OpenLocalSystemProductKey(szProduct, &userdata, FALSE);
737 else
738 MSIREG_OpenCurrentUserInstallProps(szProduct, &userdata, FALSE);
739
740 if (!lstrcmpW(szAttribute, INSTALLPROPERTY_HELPLINKW) ||
741 !lstrcmpW(szAttribute, INSTALLPROPERTY_HELPTELEPHONEW) ||
742 !lstrcmpW(szAttribute, INSTALLPROPERTY_INSTALLDATEW) ||
743 !lstrcmpW(szAttribute, INSTALLPROPERTY_INSTALLEDPRODUCTNAMEW) ||
744 !lstrcmpW(szAttribute, INSTALLPROPERTY_INSTALLLOCATIONW) ||
745 !lstrcmpW(szAttribute, INSTALLPROPERTY_INSTALLSOURCEW) ||
746 !lstrcmpW(szAttribute, INSTALLPROPERTY_LOCALPACKAGEW) ||
747 !lstrcmpW(szAttribute, INSTALLPROPERTY_PUBLISHERW) ||
748 !lstrcmpW(szAttribute, INSTALLPROPERTY_URLINFOABOUTW) ||
749 !lstrcmpW(szAttribute, INSTALLPROPERTY_URLUPDATEINFOW) ||
750 !lstrcmpW(szAttribute, INSTALLPROPERTY_VERSIONMINORW) ||
751 !lstrcmpW(szAttribute, INSTALLPROPERTY_VERSIONMAJORW) ||
752 !lstrcmpW(szAttribute, INSTALLPROPERTY_VERSIONSTRINGW) ||
753 !lstrcmpW(szAttribute, INSTALLPROPERTY_PRODUCTIDW) ||
754 !lstrcmpW(szAttribute, INSTALLPROPERTY_REGCOMPANYW) ||
755 !lstrcmpW(szAttribute, INSTALLPROPERTY_REGOWNERW))
756 {
757 if (!prodkey)
758 {
759 r = ERROR_UNKNOWN_PRODUCT;
760 goto done;
761 }
762
763 if (!userdata)
764 return ERROR_UNKNOWN_PROPERTY;
765
766 if (!lstrcmpW(szAttribute, INSTALLPROPERTY_INSTALLEDPRODUCTNAMEW))
767 szAttribute = display_name;
768 else if (!lstrcmpW(szAttribute, INSTALLPROPERTY_VERSIONSTRINGW))
769 szAttribute = display_version;
770
771 val = msi_reg_get_value(userdata, szAttribute, &type);
772 if (!val)
773 val = empty;
774 }
775 else if (!lstrcmpW(szAttribute, INSTALLPROPERTY_INSTANCETYPEW) ||
776 !lstrcmpW(szAttribute, INSTALLPROPERTY_TRANSFORMSW) ||
777 !lstrcmpW(szAttribute, INSTALLPROPERTY_LANGUAGEW) ||
778 !lstrcmpW(szAttribute, INSTALLPROPERTY_PRODUCTNAMEW) ||
779 !lstrcmpW(szAttribute, INSTALLPROPERTY_ASSIGNMENTTYPEW) ||
780 !lstrcmpW(szAttribute, INSTALLPROPERTY_PACKAGECODEW) ||
781 !lstrcmpW(szAttribute, INSTALLPROPERTY_VERSIONW) ||
782 !lstrcmpW(szAttribute, INSTALLPROPERTY_PRODUCTICONW) ||
783 !lstrcmpW(szAttribute, INSTALLPROPERTY_PACKAGENAMEW) ||
784 !lstrcmpW(szAttribute, INSTALLPROPERTY_AUTHORIZED_LUA_APPW))
785 {
786 if (!prodkey)
787 {
788 r = ERROR_UNKNOWN_PRODUCT;
789 goto done;
790 }
791
792 if (!lstrcmpW(szAttribute, INSTALLPROPERTY_ASSIGNMENTTYPEW))
793 szAttribute = assignment;
794
795 if (!lstrcmpW(szAttribute, INSTALLPROPERTY_PACKAGENAMEW))
796 {
797 res = RegOpenKeyW(prodkey, sourcelist, &source);
798 if (res == ERROR_SUCCESS)
799 val = msi_reg_get_value(source, szAttribute, &type);
800
801 RegCloseKey(source);
802 }
803 else
804 {
805 val = msi_reg_get_value(prodkey, szAttribute, &type);
806 if (!val)
807 val = empty;
808 }
809
810 if (val != empty && type != REG_DWORD &&
811 !lstrcmpW(szAttribute, INSTALLPROPERTY_PACKAGECODEW))
812 {
813 if (lstrlenW(val) != SQUISH_GUID_SIZE - 1)
814 badconfig = TRUE;
815 else
816 {
817 unsquash_guid(val, packagecode);
818 msi_free(val);
819 val = strdupW(packagecode);
820 }
821 }
822 }
823
824 if (!val)
825 {
826 r = ERROR_UNKNOWN_PROPERTY;
827 goto done;
828 }
829
830 if (pcchValueBuf)
831 {
832 save = *pcchValueBuf;
833
834 if (strlenW(val) < *pcchValueBuf)
835 r = msi_strcpy_to_awstring(val, szValue, pcchValueBuf);
836 else if (szValue->str.a || szValue->str.w)
837 r = ERROR_MORE_DATA;
838
839 if (!badconfig)
840 *pcchValueBuf = lstrlenW(val);
841 else if (r == ERROR_SUCCESS)
842 {
843 *pcchValueBuf = save;
844 r = ERROR_BAD_CONFIGURATION;
845 }
846 }
847 else if (badconfig)
848 r = ERROR_BAD_CONFIGURATION;
849
850 if (val != empty)
851 msi_free(val);
852
853 done:
854 RegCloseKey(prodkey);
855 RegCloseKey(userdata);
856 return r;
857 }
858
859 UINT WINAPI MsiGetProductInfoA(LPCSTR szProduct, LPCSTR szAttribute,
860 LPSTR szBuffer, LPDWORD pcchValueBuf)
861 {
862 LPWSTR szwProduct, szwAttribute = NULL;
863 UINT r = ERROR_OUTOFMEMORY;
864 awstring buffer;
865
866 TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szAttribute),
867 szBuffer, pcchValueBuf);
868
869 szwProduct = strdupAtoW( szProduct );
870 if( szProduct && !szwProduct )
871 goto end;
872
873 szwAttribute = strdupAtoW( szAttribute );
874 if( szAttribute && !szwAttribute )
875 goto end;
876
877 buffer.unicode = FALSE;
878 buffer.str.a = szBuffer;
879
880 r = MSI_GetProductInfo( szwProduct, szwAttribute,
881 &buffer, pcchValueBuf );
882
883 end:
884 msi_free( szwProduct );
885 msi_free( szwAttribute );
886
887 return r;
888 }
889
890 UINT WINAPI MsiGetProductInfoW(LPCWSTR szProduct, LPCWSTR szAttribute,
891 LPWSTR szBuffer, LPDWORD pcchValueBuf)
892 {
893 awstring buffer;
894
895 TRACE("%s %s %p %p\n", debugstr_w(szProduct), debugstr_w(szAttribute),
896 szBuffer, pcchValueBuf);
897
898 buffer.unicode = TRUE;
899 buffer.str.w = szBuffer;
900
901 return MSI_GetProductInfo( szProduct, szAttribute,
902 &buffer, pcchValueBuf );
903 }
904
905 UINT WINAPI MsiGetProductInfoExA(LPCSTR szProductCode, LPCSTR szUserSid,
906 MSIINSTALLCONTEXT dwContext, LPCSTR szProperty,
907 LPSTR szValue, LPDWORD pcchValue)
908 {
909 LPWSTR product = NULL;
910 LPWSTR usersid = NULL;
911 LPWSTR property = NULL;
912 LPWSTR value = NULL;
913 DWORD len = 0;
914 UINT r;
915
916 TRACE("(%s, %s, %d, %s, %p, %p)\n", debugstr_a(szProductCode),
917 debugstr_a(szUserSid), dwContext, debugstr_a(szProperty),
918 szValue, pcchValue);
919
920 if (szValue && !pcchValue)
921 return ERROR_INVALID_PARAMETER;
922
923 if (szProductCode) product = strdupAtoW(szProductCode);
924 if (szUserSid) usersid = strdupAtoW(szUserSid);
925 if (szProperty) property = strdupAtoW(szProperty);
926
927 r = MsiGetProductInfoExW(product, usersid, dwContext, property,
928 NULL, &len);
929 if (r != ERROR_SUCCESS)
930 goto done;
931
932 value = msi_alloc(++len * sizeof(WCHAR));
933 if (!value)
934 {
935 r = ERROR_OUTOFMEMORY;
936 goto done;
937 }
938
939 r = MsiGetProductInfoExW(product, usersid, dwContext, property,
940 value, &len);
941 if (r != ERROR_SUCCESS)
942 goto done;
943
944 if (!pcchValue)
945 goto done;
946
947 len = WideCharToMultiByte(CP_ACP, 0, value, -1, NULL, 0, NULL, NULL);
948 if (*pcchValue >= len)
949 WideCharToMultiByte(CP_ACP, 0, value, -1, szValue, len, NULL, NULL);
950 else if (szValue)
951 {
952 r = ERROR_MORE_DATA;
953 if (*pcchValue > 0)
954 *szValue = '\0';
955 }
956
957 if (*pcchValue <= len || !szValue)
958 len = len * sizeof(WCHAR) - 1;
959
960 *pcchValue = len - 1;
961
962 done:
963 msi_free(product);
964 msi_free(usersid);
965 msi_free(property);
966 msi_free(value);
967
968 return r;
969 }
970
971 static UINT msi_copy_outval(LPWSTR val, LPWSTR out, LPDWORD size)
972 {
973 UINT r;
974
975 if (!val)
976 return ERROR_UNKNOWN_PROPERTY;
977
978 if (out)
979 {
980 if (strlenW(val) >= *size)
981 {
982 r = ERROR_MORE_DATA;
983 if (*size > 0)
984 *out = '\0';
985 }
986 else
987 lstrcpyW(out, val);
988 }
989
990 if (size)
991 *size = lstrlenW(val);
992
993 return ERROR_SUCCESS;
994 }
995
996 UINT WINAPI MsiGetProductInfoExW(LPCWSTR szProductCode, LPCWSTR szUserSid,
997 MSIINSTALLCONTEXT dwContext, LPCWSTR szProperty,
998 LPWSTR szValue, LPDWORD pcchValue)
999 {
1000 WCHAR squished_pc[GUID_SIZE];
1001 LPWSTR val = NULL;
1002 LPCWSTR package = NULL;
1003 HKEY props = NULL, prod;
1004 HKEY classes = NULL, managed;
1005 HKEY hkey = NULL;
1006 DWORD type;
1007 UINT r = ERROR_UNKNOWN_PRODUCT;
1008
1009 static const WCHAR one[] = {'1',0};
1010 static const WCHAR five[] = {'5',0};
1011 static const WCHAR empty[] = {0};
1012 static const WCHAR displayname[] = {
1013 'D','i','s','p','l','a','y','N','a','m','e',0};
1014 static const WCHAR displayversion[] = {
1015 'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0};
1016 static const WCHAR managed_local_package[] = {
1017 'M','a','n','a','g','e','d','L','o','c','a','l',
1018 'P','a','c','k','a','g','e',0};
1019
1020 TRACE("(%s, %s, %d, %s, %p, %p)\n", debugstr_w(szProductCode),
1021 debugstr_w(szUserSid), dwContext, debugstr_w(szProperty),
1022 szValue, pcchValue);
1023
1024 if (!szProductCode || !squash_guid(szProductCode, squished_pc))
1025 return ERROR_INVALID_PARAMETER;
1026
1027 if (szValue && !pcchValue)
1028 return ERROR_INVALID_PARAMETER;
1029
1030 if (dwContext != MSIINSTALLCONTEXT_USERUNMANAGED &&
1031 dwContext != MSIINSTALLCONTEXT_USERMANAGED &&
1032 dwContext != MSIINSTALLCONTEXT_MACHINE)
1033 return ERROR_INVALID_PARAMETER;
1034
1035 if (!szProperty || !*szProperty)
1036 return ERROR_INVALID_PARAMETER;
1037
1038 if (dwContext == MSIINSTALLCONTEXT_MACHINE && szUserSid)
1039 return ERROR_INVALID_PARAMETER;
1040
1041 MSIREG_OpenProductKey(szProductCode, MSIINSTALLCONTEXT_USERMANAGED,
1042 &managed, FALSE);
1043 MSIREG_OpenProductKey(szProductCode, MSIINSTALLCONTEXT_USERUNMANAGED,
1044 &prod, FALSE);
1045
1046 if (dwContext == MSIINSTALLCONTEXT_USERUNMANAGED)
1047 {
1048 package = INSTALLPROPERTY_LOCALPACKAGEW;
1049 MSIREG_OpenCurrentUserInstallProps(szProductCode, &props, FALSE);
1050
1051 if (!props && !prod)
1052 goto done;
1053 }
1054 else if (dwContext == MSIINSTALLCONTEXT_USERMANAGED)
1055 {
1056 package = managed_local_package;
1057 MSIREG_OpenCurrentUserInstallProps(szProductCode, &props, FALSE);
1058
1059 if (!props && !managed)
1060 goto done;
1061 }
1062 else if (dwContext == MSIINSTALLCONTEXT_MACHINE)
1063 {
1064 package = INSTALLPROPERTY_LOCALPACKAGEW;
1065 MSIREG_OpenLocalSystemProductKey(szProductCode, &props, FALSE);
1066 MSIREG_OpenProductKey(szProductCode, dwContext, &classes, FALSE);
1067
1068 if (!props && !classes)
1069 goto done;
1070 }
1071
1072 if (!lstrcmpW(szProperty, INSTALLPROPERTY_HELPLINKW) ||
1073 !lstrcmpW(szProperty, INSTALLPROPERTY_HELPTELEPHONEW) ||
1074 !lstrcmpW(szProperty, INSTALLPROPERTY_INSTALLDATEW) ||
1075 !lstrcmpW(szProperty, INSTALLPROPERTY_INSTALLEDPRODUCTNAMEW) ||
1076 !lstrcmpW(szProperty, INSTALLPROPERTY_INSTALLLOCATIONW) ||
1077 !lstrcmpW(szProperty, INSTALLPROPERTY_INSTALLSOURCEW) ||
1078 !lstrcmpW(szProperty, INSTALLPROPERTY_LOCALPACKAGEW) ||
1079 !lstrcmpW(szProperty, INSTALLPROPERTY_PUBLISHERW) ||
1080 !lstrcmpW(szProperty, INSTALLPROPERTY_URLINFOABOUTW) ||
1081 !lstrcmpW(szProperty, INSTALLPROPERTY_URLUPDATEINFOW) ||
1082 !lstrcmpW(szProperty, INSTALLPROPERTY_VERSIONMINORW) ||
1083 !lstrcmpW(szProperty, INSTALLPROPERTY_VERSIONMAJORW) ||
1084 !lstrcmpW(szProperty, INSTALLPROPERTY_VERSIONSTRINGW) ||
1085 !lstrcmpW(szProperty, INSTALLPROPERTY_PRODUCTIDW) ||
1086 !lstrcmpW(szProperty, INSTALLPROPERTY_REGCOMPANYW) ||
1087 !lstrcmpW(szProperty, INSTALLPROPERTY_REGOWNERW) ||
1088 !lstrcmpW(szProperty, INSTALLPROPERTY_INSTANCETYPEW))
1089 {
1090 val = msi_reg_get_value(props, package, &type);
1091 if (!val)
1092 {
1093 if (prod || classes)
1094 r = ERROR_UNKNOWN_PROPERTY;
1095
1096 goto done;
1097 }
1098
1099 msi_free(val);
1100
1101 if (!lstrcmpW(szProperty, INSTALLPROPERTY_INSTALLEDPRODUCTNAMEW))
1102 szProperty = displayname;
1103 else if (!lstrcmpW(szProperty, INSTALLPROPERTY_VERSIONSTRINGW))
1104 szProperty = displayversion;
1105
1106 val = msi_reg_get_value(props, szProperty, &type);
1107 if (!val)
1108 val = strdupW(empty);
1109
1110 r = msi_copy_outval(val, szValue, pcchValue);
1111 }
1112 else if (!lstrcmpW(szProperty, INSTALLPROPERTY_TRANSFORMSW) ||
1113 !lstrcmpW(szProperty, INSTALLPROPERTY_LANGUAGEW) ||
1114 !lstrcmpW(szProperty, INSTALLPROPERTY_PRODUCTNAMEW) ||
1115 !lstrcmpW(szProperty, INSTALLPROPERTY_PACKAGECODEW) ||
1116 !lstrcmpW(szProperty, INSTALLPROPERTY_VERSIONW) ||
1117 !lstrcmpW(szProperty, INSTALLPROPERTY_PRODUCTICONW) ||
1118 !lstrcmpW(szProperty, INSTALLPROPERTY_PACKAGENAMEW) ||
1119 !lstrcmpW(szProperty, INSTALLPROPERTY_AUTHORIZED_LUA_APPW))
1120 {
1121 if (!prod && !classes)
1122 goto done;
1123
1124 if (dwContext == MSIINSTALLCONTEXT_USERUNMANAGED)
1125 hkey = prod;
1126 else if (dwContext == MSIINSTALLCONTEXT_USERMANAGED)
1127 hkey = managed;
1128 else if (dwContext == MSIINSTALLCONTEXT_MACHINE)
1129 hkey = classes;
1130
1131 val = msi_reg_get_value(hkey, szProperty, &type);
1132 if (!val)
1133 val = strdupW(empty);
1134
1135 r = msi_copy_outval(val, szValue, pcchValue);
1136 }
1137 else if (!lstrcmpW(szProperty, INSTALLPROPERTY_PRODUCTSTATEW))
1138 {
1139 if (dwContext == MSIINSTALLCONTEXT_MACHINE)
1140 {
1141 if (props)
1142 {
1143 val = msi_reg_get_value(props, package, &type);
1144 if (!val)
1145 goto done;
1146
1147 msi_free(val);
1148 val = strdupW(five);
1149 }
1150 else
1151 val = strdupW(one);
1152
1153 r = msi_copy_outval(val, szValue, pcchValue);
1154 goto done;
1155 }
1156 else if (props && (val = msi_reg_get_value(props, package, &type)))
1157 {
1158 msi_free(val);
1159 val = strdupW(five);
1160 r = msi_copy_outval(val, szValue, pcchValue);
1161 goto done;
1162 }
1163
1164 if (prod || managed)
1165 val = strdupW(one);
1166 else
1167 goto done;
1168
1169 r = msi_copy_outval(val, szValue, pcchValue);
1170 }
1171 else if (!lstrcmpW(szProperty, INSTALLPROPERTY_ASSIGNMENTTYPEW))
1172 {
1173 if (!prod && !classes)
1174 goto done;
1175
1176 /* FIXME */
1177 val = strdupW(empty);
1178 r = msi_copy_outval(val, szValue, pcchValue);
1179 }
1180 else
1181 r = ERROR_UNKNOWN_PROPERTY;
1182
1183 done:
1184 RegCloseKey(props);
1185 RegCloseKey(prod);
1186 RegCloseKey(managed);
1187 RegCloseKey(classes);
1188 msi_free(val);
1189
1190 return r;
1191 }
1192
1193 UINT WINAPI MsiEnableLogA(DWORD dwLogMode, LPCSTR szLogFile, DWORD attributes)
1194 {
1195 LPWSTR szwLogFile = NULL;
1196 UINT r;
1197
1198 TRACE("%08x %s %08x\n", dwLogMode, debugstr_a(szLogFile), attributes);
1199
1200 if( szLogFile )
1201 {
1202 szwLogFile = strdupAtoW( szLogFile );
1203 if( !szwLogFile )
1204 return ERROR_OUTOFMEMORY;
1205 }
1206 r = MsiEnableLogW( dwLogMode, szwLogFile, attributes );
1207 msi_free( szwLogFile );
1208 return r;
1209 }
1210
1211 UINT WINAPI MsiEnableLogW(DWORD dwLogMode, LPCWSTR szLogFile, DWORD attributes)
1212 {
1213 HANDLE file = INVALID_HANDLE_VALUE;
1214
1215 TRACE("%08x %s %08x\n", dwLogMode, debugstr_w(szLogFile), attributes);
1216
1217 if (szLogFile)
1218 {
1219 lstrcpyW(gszLogFile,szLogFile);
1220 if (!(attributes & INSTALLLOGATTRIBUTES_APPEND))
1221 DeleteFileW(szLogFile);
1222 file = CreateFileW(szLogFile, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS,
1223 FILE_ATTRIBUTE_NORMAL, NULL);
1224 if (file != INVALID_HANDLE_VALUE)
1225 CloseHandle(file);
1226 else
1227 ERR("Unable to enable log %s\n",debugstr_w(szLogFile));
1228 }
1229 else
1230 gszLogFile[0] = '\0';
1231
1232 return ERROR_SUCCESS;
1233 }
1234
1235 UINT WINAPI MsiEnumComponentCostsW(MSIHANDLE hInstall, LPCWSTR szComponent,
1236 DWORD dwIndex, INSTALLSTATE iState,
1237 LPWSTR lpDriveBuf, DWORD *pcchDriveBuf,
1238 int *piCost, int *pTempCost)
1239 {
1240 FIXME("(%ld, %s, %d, %d, %p, %p, %p %p): stub!\n", hInstall,
1241 debugstr_w(szComponent), dwIndex, iState, lpDriveBuf,
1242 pcchDriveBuf, piCost, pTempCost);
1243
1244 return ERROR_NO_MORE_ITEMS;
1245 }
1246
1247 UINT WINAPI MsiQueryComponentStateA(LPCSTR szProductCode,
1248 LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext,
1249 LPCSTR szComponent, INSTALLSTATE *pdwState)
1250 {
1251 LPWSTR prodcode = NULL, usersid = NULL, comp = NULL;
1252 UINT r;
1253
1254 TRACE("(%s, %s, %d, %s, %p)\n", debugstr_a(szProductCode),
1255 debugstr_a(szUserSid), dwContext, debugstr_a(szComponent), pdwState);
1256
1257 if (szProductCode && !(prodcode = strdupAtoW(szProductCode)))
1258 return ERROR_OUTOFMEMORY;
1259
1260 if (szUserSid && !(usersid = strdupAtoW(szUserSid)))
1261 return ERROR_OUTOFMEMORY;
1262
1263 if (szComponent && !(comp = strdupAtoW(szComponent)))
1264 return ERROR_OUTOFMEMORY;
1265
1266 r = MsiQueryComponentStateW(prodcode, usersid, dwContext, comp, pdwState);
1267
1268 msi_free(prodcode);
1269 msi_free(usersid);
1270 msi_free(comp);
1271
1272 return r;
1273 }
1274
1275 static BOOL msi_comp_find_prod_key(LPCWSTR prodcode, MSIINSTALLCONTEXT context)
1276 {
1277 UINT r;
1278 HKEY hkey;
1279
1280 r = MSIREG_OpenProductKey(prodcode, context, &hkey, FALSE);
1281 RegCloseKey(hkey);
1282 return (r == ERROR_SUCCESS);
1283 }
1284
1285 static BOOL msi_comp_find_package(LPCWSTR prodcode, MSIINSTALLCONTEXT context)
1286 {
1287 LPCWSTR package;
1288 HKEY hkey;
1289 DWORD sz;
1290 LONG res;
1291 UINT r;
1292
1293 static const WCHAR local_package[] = {'L','o','c','a','l','P','a','c','k','a','g','e',0};
1294 static const WCHAR managed_local_package[] = {
1295 'M','a','n','a','g','e','d','L','o','c','a','l','P','a','c','k','a','g','e',0
1296 };
1297
1298 if (context == MSIINSTALLCONTEXT_MACHINE)
1299 r = MSIREG_OpenLocalSystemProductKey(prodcode, &hkey, FALSE);
1300 else
1301 r = MSIREG_OpenCurrentUserInstallProps(prodcode, &hkey, FALSE);
1302
1303 if (r != ERROR_SUCCESS)
1304 return FALSE;
1305
1306 if (context == MSIINSTALLCONTEXT_USERMANAGED)
1307 package = managed_local_package;
1308 else
1309 package = local_package;
1310
1311 sz = 0;
1312 res = RegQueryValueExW(hkey, package, NULL, NULL, NULL, &sz);
1313 RegCloseKey(hkey);
1314
1315 return (res == ERROR_SUCCESS);
1316 }
1317
1318 static BOOL msi_comp_find_prodcode(LPWSTR squished_pc,
1319 MSIINSTALLCONTEXT context,
1320 LPCWSTR comp, LPWSTR val, DWORD *sz)
1321 {
1322 HKEY hkey;
1323 LONG res;
1324 UINT r;
1325
1326 if (context == MSIINSTALLCONTEXT_MACHINE)
1327 r = MSIREG_OpenLocalSystemComponentKey(comp, &hkey, FALSE);
1328 else
1329 r = MSIREG_OpenUserDataComponentKey(comp, &hkey, FALSE);
1330
1331 if (r != ERROR_SUCCESS)
1332 return FALSE;
1333
1334 res = RegQueryValueExW(hkey, squished_pc, NULL, NULL, (BYTE *)val, sz);
1335 if (res != ERROR_SUCCESS)
1336 return FALSE;
1337
1338 RegCloseKey(hkey);
1339 return TRUE;
1340 }
1341
1342 UINT WINAPI MsiQueryComponentStateW(LPCWSTR szProductCode,
1343 LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext,
1344 LPCWSTR szComponent, INSTALLSTATE *pdwState)
1345 {
1346 WCHAR squished_pc[GUID_SIZE];
1347 WCHAR val[MAX_PATH];
1348 BOOL found;
1349 DWORD sz;
1350
1351 TRACE("(%s, %s, %d, %s, %p)\n", debugstr_w(szProductCode),
1352 debugstr_w(szUserSid), dwContext, debugstr_w(szComponent), pdwState);
1353
1354 if (!pdwState)
1355 return ERROR_INVALID_PARAMETER;
1356
1357 if (!szProductCode || !*szProductCode || lstrlenW(szProductCode) != GUID_SIZE - 1)
1358 return ERROR_INVALID_PARAMETER;
1359
1360 if (!squash_guid(szProductCode, squished_pc))
1361 return ERROR_INVALID_PARAMETER;
1362
1363 found = msi_comp_find_prod_key(szProductCode, dwContext);
1364
1365 if (!msi_comp_find_package(szProductCode, dwContext))
1366 {
1367 if (found)
1368 {
1369 *pdwState = INSTALLSTATE_UNKNOWN;
1370 return ERROR_UNKNOWN_COMPONENT;
1371 }
1372
1373 return ERROR_UNKNOWN_PRODUCT;
1374 }
1375
1376 *pdwState = INSTALLSTATE_UNKNOWN;
1377
1378 sz = MAX_PATH;
1379 if (!msi_comp_find_prodcode(squished_pc, dwContext, szComponent, val, &sz))
1380 return ERROR_UNKNOWN_COMPONENT;
1381
1382 if (sz == 0)
1383 *pdwState = INSTALLSTATE_NOTUSED;
1384 else
1385 {
1386 if (lstrlenW(val) > 2 &&
1387 val[0] >= '0' && val[0] <= '9' && val[1] >= '0' && val[1] <= '9')
1388 {
1389 *pdwState = INSTALLSTATE_SOURCE;
1390 }
1391 else
1392 *pdwState = INSTALLSTATE_LOCAL;
1393 }
1394
1395 return ERROR_SUCCESS;
1396 }
1397
1398 INSTALLSTATE WINAPI MsiQueryProductStateA(LPCSTR szProduct)
1399 {
1400 LPWSTR szwProduct = NULL;
1401 INSTALLSTATE r;
1402
1403 if( szProduct )
1404 {
1405 szwProduct = strdupAtoW( szProduct );
1406 if( !szwProduct )
1407 return ERROR_OUTOFMEMORY;
1408 }
1409 r = MsiQueryProductStateW( szwProduct );
1410 msi_free( szwProduct );
1411 return r;
1412 }
1413
1414 INSTALLSTATE WINAPI MsiQueryProductStateW(LPCWSTR szProduct)
1415 {
1416 INSTALLSTATE state = INSTALLSTATE_ADVERTISED;
1417 HKEY prodkey = 0, userdata = 0;
1418 BOOL user = TRUE;
1419 DWORD val;
1420 UINT r;
1421
1422 static const WCHAR szWindowsInstaller[] = {
1423 'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
1424
1425 TRACE("%s\n", debugstr_w(szProduct));
1426
1427 if (!szProduct || !*szProduct)
1428 return INSTALLSTATE_INVALIDARG;
1429
1430 if (lstrlenW(szProduct) != GUID_SIZE - 1)
1431 return INSTALLSTATE_INVALIDARG;
1432
1433 if (MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_USERMANAGED,
1434 &prodkey, FALSE) != ERROR_SUCCESS &&
1435 MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
1436 &prodkey, FALSE) != ERROR_SUCCESS &&
1437 MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_MACHINE,
1438 &prodkey, FALSE) == ERROR_SUCCESS)
1439 {
1440 user = FALSE;
1441 }
1442
1443 if (user)
1444 {
1445 r = MSIREG_OpenCurrentUserInstallProps(szProduct, &userdata, FALSE);
1446 if (r != ERROR_SUCCESS)
1447 goto done;
1448 }
1449 else
1450 {
1451 r = MSIREG_OpenLocalSystemInstallProps(szProduct, &userdata, FALSE);
1452 if (r != ERROR_SUCCESS)
1453 goto done;
1454 }
1455
1456 if (!msi_reg_get_val_dword(userdata, szWindowsInstaller, &val))
1457 goto done;
1458
1459 if (val)
1460 state = INSTALLSTATE_DEFAULT;
1461 else
1462 state = INSTALLSTATE_UNKNOWN;
1463
1464 done:
1465 if (!prodkey)
1466 {
1467 state = INSTALLSTATE_UNKNOWN;
1468
1469 if (userdata)
1470 state = INSTALLSTATE_ABSENT;
1471 }
1472
1473 RegCloseKey(prodkey);
1474 RegCloseKey(userdata);
1475 return state;
1476 }
1477
1478 INSTALLUILEVEL WINAPI MsiSetInternalUI(INSTALLUILEVEL dwUILevel, HWND *phWnd)
1479 {
1480 INSTALLUILEVEL old = gUILevel;
1481 HWND oldwnd = gUIhwnd;
1482
1483 TRACE("%08x %p\n", dwUILevel, phWnd);
1484
1485 gUILevel = dwUILevel;
1486 if (phWnd)
1487 {
1488 gUIhwnd = *phWnd;
1489 *phWnd = oldwnd;
1490 }
1491 return old;
1492 }
1493
1494 INSTALLUI_HANDLERA WINAPI MsiSetExternalUIA(INSTALLUI_HANDLERA puiHandler,
1495 DWORD dwMessageFilter, LPVOID pvContext)
1496 {
1497 INSTALLUI_HANDLERA prev = gUIHandlerA;
1498
1499 TRACE("%p %x %p\n",puiHandler, dwMessageFilter,pvContext);
1500 gUIHandlerA = puiHandler;
1501 gUIFilter = dwMessageFilter;
1502 gUIContext = pvContext;
1503
1504 return prev;
1505 }
1506
1507 INSTALLUI_HANDLERW WINAPI MsiSetExternalUIW(INSTALLUI_HANDLERW puiHandler,
1508 DWORD dwMessageFilter, LPVOID pvContext)
1509 {
1510 INSTALLUI_HANDLERW prev = gUIHandlerW;
1511
1512 TRACE("%p %x %p\n",puiHandler,dwMessageFilter,pvContext);
1513 gUIHandlerW = puiHandler;
1514 gUIFilter = dwMessageFilter;
1515 gUIContext = pvContext;
1516
1517 return prev;
1518 }
1519
1520 /******************************************************************
1521 * MsiLoadStringW [MSI.@]
1522 *
1523 * Loads a string from MSI's string resources.
1524 *
1525 * PARAMS
1526 *
1527 * handle [I] only -1 is handled currently
1528 * id [I] id of the string to be loaded
1529 * lpBuffer [O] buffer for the string to be written to
1530 * nBufferMax [I] maximum size of the buffer in characters
1531 * lang [I] the preferred language for the string
1532 *
1533 * RETURNS
1534 *
1535 * If successful, this function returns the language id of the string loaded
1536 * If the function fails, the function returns zero.
1537 *
1538 * NOTES
1539 *
1540 * The type of the first parameter is unknown. LoadString's prototype
1541 * suggests that it might be a module handle. I have made it an MSI handle
1542 * for starters, as -1 is an invalid MSI handle, but not an invalid module
1543 * handle. Maybe strings can be stored in an MSI database somehow.
1544 */
1545 LANGID WINAPI MsiLoadStringW( MSIHANDLE handle, UINT id, LPWSTR lpBuffer,
1546 int nBufferMax, LANGID lang )
1547 {
1548 HRSRC hres;
1549 HGLOBAL hResData;
1550 LPWSTR p;
1551 DWORD i, len;
1552
1553 TRACE("%ld %u %p %d %d\n", handle, id, lpBuffer, nBufferMax, lang);
1554
1555 if( handle != -1 )
1556 FIXME("don't know how to deal with handle = %08lx\n", handle);
1557
1558 if( !lang )
1559 lang = GetUserDefaultLangID();
1560
1561 hres = FindResourceExW( msi_hInstance, (LPCWSTR) RT_STRING,
1562 (LPWSTR)1, lang );
1563 if( !hres )
1564 return 0;
1565 hResData = LoadResource( msi_hInstance, hres );
1566 if( !hResData )
1567 return 0;
1568 p = LockResource( hResData );
1569 if( !p )
1570 return 0;
1571
1572 for (i = 0; i < (id&0xf); i++)
1573 p += *p + 1;
1574 len = *p;
1575
1576 if( nBufferMax <= len )
1577 return 0;
1578
1579 memcpy( lpBuffer, p+1, len * sizeof(WCHAR));
1580 lpBuffer[ len ] = 0;
1581
1582 TRACE("found -> %s\n", debugstr_w(lpBuffer));
1583
1584 return lang;
1585 }
1586
1587 LANGID WINAPI MsiLoadStringA( MSIHANDLE handle, UINT id, LPSTR lpBuffer,
1588 int nBufferMax, LANGID lang )
1589 {
1590 LPWSTR bufW;
1591 LANGID r;
1592 INT len;
1593
1594 bufW = msi_alloc(nBufferMax*sizeof(WCHAR));
1595 r = MsiLoadStringW(handle, id, bufW, nBufferMax, lang);
1596 if( r )
1597 {
1598 len = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL, NULL );
1599 if( len <= nBufferMax )
1600 WideCharToMultiByte( CP_ACP, 0, bufW, -1,
1601 lpBuffer, nBufferMax, NULL, NULL );
1602 else
1603 r = 0;
1604 }
1605 msi_free(bufW);
1606 return r;
1607 }
1608
1609 INSTALLSTATE WINAPI MsiLocateComponentA(LPCSTR szComponent, LPSTR lpPathBuf,
1610 LPDWORD pcchBuf)
1611 {
1612 char szProduct[GUID_SIZE];
1613
1614 TRACE("%s %p %p\n", debugstr_a(szComponent), lpPathBuf, pcchBuf);
1615
1616 if (MsiGetProductCodeA( szComponent, szProduct ) != ERROR_SUCCESS)
1617 return INSTALLSTATE_UNKNOWN;
1618
1619 return MsiGetComponentPathA( szProduct, szComponent, lpPathBuf, pcchBuf );
1620 }
1621
1622 INSTALLSTATE WINAPI MsiLocateComponentW(LPCWSTR szComponent, LPWSTR lpPathBuf,
1623 LPDWORD pcchBuf)
1624 {
1625 WCHAR szProduct[GUID_SIZE];
1626
1627 TRACE("%s %p %p\n", debugstr_w(szComponent), lpPathBuf, pcchBuf);
1628
1629 if (MsiGetProductCodeW( szComponent, szProduct ) != ERROR_SUCCESS)
1630 return INSTALLSTATE_UNKNOWN;
1631
1632 return MsiGetComponentPathW( szProduct, szComponent, lpPathBuf, pcchBuf );
1633 }
1634
1635 UINT WINAPI MsiMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,
1636 WORD wLanguageId, DWORD f)
1637 {
1638 FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_a(lpText), debugstr_a(lpCaption),
1639 uType, wLanguageId, f);
1640 return MessageBoxExA(hWnd,lpText,lpCaption,uType,wLanguageId);
1641 }
1642
1643 UINT WINAPI MsiMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,
1644 WORD wLanguageId, DWORD f)
1645 {
1646 FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_w(lpText), debugstr_w(lpCaption),
1647 uType, wLanguageId, f);
1648 return MessageBoxExW(hWnd,lpText,lpCaption,uType,wLanguageId);
1649 }
1650
1651 UINT WINAPI MsiProvideAssemblyA( LPCSTR szAssemblyName, LPCSTR szAppContext,
1652 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPSTR lpPathBuf,
1653 LPDWORD pcchPathBuf )
1654 {
1655 FIXME("%s %s %08x %08x %p %p\n", debugstr_a(szAssemblyName),
1656 debugstr_a(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
1657 pcchPathBuf);
1658 return ERROR_CALL_NOT_IMPLEMENTED;
1659 }
1660
1661 UINT WINAPI MsiProvideAssemblyW( LPCWSTR szAssemblyName, LPCWSTR szAppContext,
1662 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPWSTR lpPathBuf,
1663 LPDWORD pcchPathBuf )
1664 {
1665 FIXME("%s %s %08x %08x %p %p\n", debugstr_w(szAssemblyName),
1666 debugstr_w(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
1667 pcchPathBuf);
1668 return ERROR_CALL_NOT_IMPLEMENTED;
1669 }
1670
1671 UINT WINAPI MsiProvideComponentFromDescriptorA( LPCSTR szDescriptor,
1672 LPSTR szPath, LPDWORD pcchPath, LPDWORD pcchArgs )
1673 {
1674 FIXME("%s %p %p %p\n", debugstr_a(szDescriptor), szPath, pcchPath, pcchArgs );
1675 return ERROR_CALL_NOT_IMPLEMENTED;
1676 }
1677
1678 UINT WINAPI MsiProvideComponentFromDescriptorW( LPCWSTR szDescriptor,
1679 LPWSTR szPath, LPDWORD pcchPath, LPDWORD pcchArgs )
1680 {
1681 FIXME("%s %p %p %p\n", debugstr_w(szDescriptor), szPath, pcchPath, pcchArgs );
1682 return ERROR_CALL_NOT_IMPLEMENTED;
1683 }
1684
1685 HRESULT WINAPI MsiGetFileSignatureInformationA( LPCSTR szSignedObjectPath,
1686 DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, LPBYTE pbHashData,
1687 LPDWORD pcbHashData)
1688 {
1689 FIXME("%s %08x %p %p %p\n", debugstr_a(szSignedObjectPath), dwFlags,
1690 ppcCertContext, pbHashData, pcbHashData);
1691 return ERROR_CALL_NOT_IMPLEMENTED;
1692 }
1693
1694 HRESULT WINAPI MsiGetFileSignatureInformationW( LPCWSTR szSignedObjectPath,
1695 DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, LPBYTE pbHashData,
1696 LPDWORD pcbHashData)
1697 {
1698 FIXME("%s %08x %p %p %p\n", debugstr_w(szSignedObjectPath), dwFlags,
1699 ppcCertContext, pbHashData, pcbHashData);
1700 return ERROR_CALL_NOT_IMPLEMENTED;
1701 }
1702
1703 UINT WINAPI MsiGetProductPropertyA( MSIHANDLE hProduct, LPCSTR szProperty,
1704 LPSTR szValue, LPDWORD pccbValue )
1705 {
1706 FIXME("%ld %s %p %p\n", hProduct, debugstr_a(szProperty), szValue, pccbValue);
1707 return ERROR_CALL_NOT_IMPLEMENTED;
1708 }
1709
1710 UINT WINAPI MsiGetProductPropertyW( MSIHANDLE hProduct, LPCWSTR szProperty,
1711 LPWSTR szValue, LPDWORD pccbValue )
1712 {
1713 FIXME("%ld %s %p %p\n", hProduct, debugstr_w(szProperty), szValue, pccbValue);
1714 return ERROR_CALL_NOT_IMPLEMENTED;
1715 }
1716
1717 UINT WINAPI MsiVerifyPackageA( LPCSTR szPackage )
1718 {
1719 UINT r;
1720 LPWSTR szPack = NULL;
1721
1722 TRACE("%s\n", debugstr_a(szPackage) );
1723
1724 if( szPackage )
1725 {
1726 szPack = strdupAtoW( szPackage );
1727 if( !szPack )
1728 return ERROR_OUTOFMEMORY;
1729 }
1730
1731 r = MsiVerifyPackageW( szPack );
1732
1733 msi_free( szPack );
1734
1735 return r;
1736 }
1737
1738 UINT WINAPI MsiVerifyPackageW( LPCWSTR szPackage )
1739 {
1740 MSIHANDLE handle;
1741 UINT r;
1742
1743 TRACE("%s\n", debugstr_w(szPackage) );
1744
1745 r = MsiOpenDatabaseW( szPackage, MSIDBOPEN_READONLY, &handle );
1746 MsiCloseHandle( handle );
1747
1748 return r;
1749 }
1750
1751 static INSTALLSTATE WINAPI MSI_GetComponentPath(LPCWSTR szProduct, LPCWSTR szComponent,
1752 awstring* lpPathBuf, LPDWORD pcchBuf)
1753 {
1754 WCHAR squished_pc[GUID_SIZE];
1755 WCHAR squished_comp[GUID_SIZE];
1756 HKEY hkey;
1757 LPWSTR path = NULL;
1758 INSTALLSTATE state;
1759 DWORD version;
1760
1761 static const WCHAR wininstaller[] = {
1762 'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
1763
1764 TRACE("%s %s %p %p\n", debugstr_w(szProduct),
1765 debugstr_w(szComponent), lpPathBuf->str.w, pcchBuf);
1766
1767 if (!szProduct || !szComponent)
1768 return INSTALLSTATE_INVALIDARG;
1769
1770 if (lpPathBuf->str.w && !pcchBuf)
1771 return INSTALLSTATE_INVALIDARG;
1772
1773 if (!squash_guid(szProduct, squished_pc) ||
1774 !squash_guid(szComponent, squished_comp))
1775 return INSTALLSTATE_INVALIDARG;
1776
1777 state = INSTALLSTATE_UNKNOWN;
1778
1779 if (MSIREG_OpenLocalSystemComponentKey(szComponent, &hkey, FALSE) == ERROR_SUCCESS ||
1780 MSIREG_OpenUserDataComponentKey(szComponent, &hkey, FALSE) == ERROR_SUCCESS)
1781 {
1782 path = msi_reg_get_val_str(hkey, squished_pc);
1783 RegCloseKey(hkey);
1784
1785 state = INSTALLSTATE_ABSENT;
1786
1787 if ((MSIREG_OpenLocalSystemProductKey(szProduct, &hkey, FALSE) == ERROR_SUCCESS ||
1788 MSIREG_OpenUserDataProductKey(szProduct, &hkey, FALSE) == ERROR_SUCCESS) &&
1789 msi_reg_get_val_dword(hkey, wininstaller, &version) &&
1790 GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
1791 {
1792 RegCloseKey(hkey);
1793 state = INSTALLSTATE_LOCAL;
1794 }
1795 }
1796
1797 if (state != INSTALLSTATE_LOCAL &&
1798 (MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
1799 &hkey, FALSE) == ERROR_SUCCESS ||
1800 MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_MACHINE,
1801 &hkey, FALSE) == ERROR_SUCCESS))
1802 {
1803 RegCloseKey(hkey);
1804
1805 if (MSIREG_OpenLocalSystemComponentKey(szComponent, &hkey, FALSE) == ERROR_SUCCESS ||
1806 MSIREG_OpenUserDataComponentKey(szComponent, &hkey, FALSE) == ERROR_SUCCESS)
1807 {
1808 msi_free(path);
1809 path = msi_reg_get_val_str(hkey, squished_pc);
1810 RegCloseKey(hkey);
1811
1812 state = INSTALLSTATE_ABSENT;
1813
1814 if (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
1815 state = INSTALLSTATE_LOCAL;
1816 }
1817 }
1818
1819 if (!path)
1820 return INSTALLSTATE_UNKNOWN;
1821
1822 if (state == INSTALLSTATE_LOCAL && !*path)
1823 state = INSTALLSTATE_NOTUSED;
1824
1825 msi_strcpy_to_awstring(path, lpPathBuf, pcchBuf);
1826 msi_free(path);
1827 return state;
1828 }
1829
1830 /******************************************************************
1831 * MsiGetComponentPathW [MSI.@]
1832 */
1833 INSTALLSTATE WINAPI MsiGetComponentPathW(LPCWSTR szProduct, LPCWSTR szComponent,
1834 LPWSTR lpPathBuf, LPDWORD pcchBuf)
1835 {
1836 awstring path;
1837
1838 path.unicode = TRUE;
1839 path.str.w = lpPathBuf;
1840
1841 return MSI_GetComponentPath( szProduct, szComponent, &path, pcchBuf );
1842 }
1843
1844 /******************************************************************
1845 * MsiGetComponentPathA [MSI.@]
1846 */
1847 INSTALLSTATE WINAPI MsiGetComponentPathA(LPCSTR szProduct, LPCSTR szComponent,
1848 LPSTR lpPathBuf, LPDWORD pcchBuf)
1849 {
1850 LPWSTR szwProduct, szwComponent = NULL;
1851 INSTALLSTATE r = INSTALLSTATE_UNKNOWN;
1852 awstring path;
1853
1854 szwProduct = strdupAtoW( szProduct );
1855 if( szProduct && !szwProduct)
1856 goto end;
1857
1858 szwComponent = strdupAtoW( szComponent );
1859 if( szComponent && !szwComponent )
1860 goto end;
1861
1862 path.unicode = FALSE;
1863 path.str.a = lpPathBuf;
1864
1865 r = MSI_GetComponentPath( szwProduct, szwComponent, &path, pcchBuf );
1866
1867 end:
1868 msi_free( szwProduct );
1869 msi_free( szwComponent );
1870
1871 return r;
1872 }
1873
1874 /******************************************************************
1875 * MsiQueryFeatureStateA [MSI.@]
1876 */
1877 INSTALLSTATE WINAPI MsiQueryFeatureStateA(LPCSTR szProduct, LPCSTR szFeature)
1878 {
1879 LPWSTR szwProduct = NULL, szwFeature= NULL;
1880 INSTALLSTATE rc = INSTALLSTATE_UNKNOWN;
1881
1882 szwProduct = strdupAtoW( szProduct );
1883 if ( szProduct && !szwProduct )
1884 goto end;
1885
1886 szwFeature = strdupAtoW( szFeature );
1887 if ( szFeature && !szwFeature )
1888 goto end;
1889
1890 rc = MsiQueryFeatureStateW(szwProduct, szwFeature);
1891
1892 end:
1893 msi_free( szwProduct);
1894 msi_free( szwFeature);
1895
1896 return rc;
1897 }
1898
1899 /******************************************************************
1900 * MsiQueryFeatureStateW [MSI.@]
1901 *
1902 * Checks the state of a feature
1903 *
1904 * PARAMS
1905 * szProduct [I] Product's GUID string
1906 * szFeature [I] Feature's GUID string
1907 *
1908 * RETURNS
1909 * INSTALLSTATE_LOCAL Feature is installed and usable
1910 * INSTALLSTATE_ABSENT Feature is absent
1911 * INSTALLSTATE_ADVERTISED Feature should be installed on demand
1912 * INSTALLSTATE_UNKNOWN An error occurred
1913 * INSTALLSTATE_INVALIDARG One of the GUIDs was invalid
1914 *
1915 */
1916 INSTALLSTATE WINAPI MsiQueryFeatureStateW(LPCWSTR szProduct, LPCWSTR szFeature)
1917 {
1918 WCHAR squishProduct[33], comp[GUID_SIZE];
1919 GUID guid;
1920 LPWSTR components, p, parent_feature, path;
1921 UINT rc;
1922 HKEY hkey;
1923 INSTALLSTATE r;
1924 BOOL missing = FALSE;
1925 BOOL machine = FALSE;
1926 BOOL source = FALSE;
1927
1928 TRACE("%s %s\n", debugstr_w(szProduct), debugstr_w(szFeature));
1929
1930 if (!szProduct || !szFeature)
1931 return INSTALLSTATE_INVALIDARG;
1932
1933 if (!squash_guid( szProduct, squishProduct ))
1934 return INSTALLSTATE_INVALIDARG;
1935
1936 if (MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_USERMANAGED,
1937 &hkey, FALSE) != ERROR_SUCCESS &&
1938 MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
1939 &hkey, FALSE) != ERROR_SUCCESS)
1940 {
1941 rc = MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_MACHINE,
1942 &hkey, FALSE);
1943 if (rc != ERROR_SUCCESS)
1944 return INSTALLSTATE_UNKNOWN;
1945
1946 machine = TRUE;
1947 }
1948
1949 parent_feature = msi_reg_get_val_str( hkey, szFeature );
1950 RegCloseKey(hkey);
1951
1952 if (!parent_feature)
1953 return INSTALLSTATE_UNKNOWN;
1954
1955 r = (parent_feature[0] == 6) ? INSTALLSTATE_ABSENT : INSTALLSTATE_LOCAL;
1956 msi_free(parent_feature);
1957 if (r == INSTALLSTATE_ABSENT)
1958 return r;
1959
1960 if (machine)
1961 rc = MSIREG_OpenUserDataFeaturesKey(szProduct,
1962 MSIINSTALLCONTEXT_MACHINE,
1963 &hkey, FALSE);
1964 else
1965 rc = MSIREG_OpenUserDataFeaturesKey(szProduct,
1966 MSIINSTALLCONTEXT_USERUNMANAGED,
1967 &hkey, FALSE);
1968
1969 if (rc != ERROR_SUCCESS)
1970 return INSTALLSTATE_ADVERTISED;
1971
1972 components = msi_reg_get_val_str( hkey, szFeature );
1973 RegCloseKey(hkey);
1974
1975 TRACE("rc = %d buffer = %s\n", rc, debugstr_w(components));
1976
1977 if (!components)
1978 return INSTALLSTATE_ADVERTISED;
1979
1980 for( p = components; *p && *p != 2 ; p += 20)
1981 {
1982 if (!decode_base85_guid( p, &guid ))
1983 {
1984 if (p != components)
1985 break;
1986
1987 msi_free(components);
1988 return INSTALLSTATE_BADCONFIG;
1989 }
1990
1991 StringFromGUID2(&guid, comp, GUID_SIZE);
1992
1993 if (machine)
1994 rc = MSIREG_OpenLocalUserDataComponentKey(comp, &hkey, FALSE);
1995 else
1996 rc = MSIREG_OpenUserDataComponentKey(comp, &hkey, FALSE);
1997
1998 if (rc != ERROR_SUCCESS)
1999 {
2000 msi_free(components);
2001 return INSTALLSTATE_ADVERTISED;
2002 }
2003
2004 path = msi_reg_get_val_str(hkey, squishProduct);
2005 if (!path)
2006 missing = TRUE;
2007 else if (lstrlenW(path) > 2 &&
2008 path[0] >= '0' && path[0] <= '9' &&
2009 path[1] >= '0' && path[1] <= '9')
2010 {
2011 source = TRUE;
2012 }
2013
2014 msi_free(path);
2015 }
2016
2017 TRACE("%s %s -> %d\n", debugstr_w(szProduct), debugstr_w(szFeature), r);
2018 msi_free(components);
2019
2020 if (missing)
2021 return INSTALLSTATE_ADVERTISED;
2022
2023 if (source)
2024 return INSTALLSTATE_SOURCE;
2025
2026 return INSTALLSTATE_LOCAL;
2027 }
2028
2029 /******************************************************************
2030 * MsiGetFileVersionA [MSI.@]
2031 */
2032 UINT WINAPI MsiGetFileVersionA(LPCSTR szFilePath, LPSTR lpVersionBuf,
2033 LPDWORD pcchVersionBuf, LPSTR lpLangBuf, LPDWORD pcchLangBuf)
2034 {
2035 LPWSTR szwFilePath = NULL, lpwVersionBuff = NULL, lpwLangBuff = NULL;
2036 UINT ret = ERROR_OUTOFMEMORY;
2037
2038 if ((lpVersionBuf && !pcchVersionBuf) ||
2039 (lpLangBuf && !pcchLangBuf))
2040 return ERROR_INVALID_PARAMETER;
2041
2042 if( szFilePath )
2043 {
2044 szwFilePath = strdupAtoW( szFilePath );
2045 if( !szwFilePath )
2046 goto end;
2047 }
2048
2049 if( lpVersionBuf && pcchVersionBuf && *pcchVersionBuf )
2050 {
2051 lpwVersionBuff = msi_alloc(*pcchVersionBuf*sizeof(WCHAR));
2052 if( !lpwVersionBuff )
2053 goto end;
2054 }
2055
2056 if( lpLangBuf && pcchLangBuf && *pcchLangBuf )
2057 {
2058 lpwLangBuff = msi_alloc(*pcchLangBuf*sizeof(WCHAR));
2059 if( !lpwLangBuff )
2060 goto end;
2061 }
2062
2063 ret = MsiGetFileVersionW(szwFilePath, lpwVersionBuff, pcchVersionBuf,
2064 lpwLangBuff, pcchLangBuf);
2065
2066 if( (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && lpwVersionBuff )
2067 WideCharToMultiByte(CP_ACP, 0, lpwVersionBuff, -1,
2068 lpVersionBuf, *pcchVersionBuf + 1, NULL, NULL);
2069 if( (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && lpwLangBuff )
2070 WideCharToMultiByte(CP_ACP, 0, lpwLangBuff, -1,
2071 lpLangBuf, *pcchLangBuf + 1, NULL, NULL);
2072
2073 end:
2074 msi_free(szwFilePath);
2075 msi_free(lpwVersionBuff);
2076 msi_free(lpwLangBuff);
2077
2078 return ret;
2079 }
2080
2081 /******************************************************************
2082 * MsiGetFileVersionW [MSI.@]
2083 */
2084 UINT WINAPI MsiGetFileVersionW(LPCWSTR szFilePath, LPWSTR lpVersionBuf,
2085 LPDWORD pcchVersionBuf, LPWSTR lpLangBuf, LPDWORD pcchLangBuf)
2086 {
2087 static const WCHAR szVersionResource[] = {'\\',0};
2088 static const WCHAR szVersionFormat[] = {
2089 '%','d','.','%','d','.','%','d','.','%','d',0};
2090 static const WCHAR szLangResource[] = {
2091 '\\','V','a','r','F','i','l','e','I','n','f','o','\\',
2092 'T','r','a','n','s','l','a','t','i','o','n',0};
2093 static const WCHAR szLangFormat[] = {'%','d',0};
2094 UINT ret = 0;
2095 DWORD dwVerLen, gle;
2096 LPVOID lpVer = NULL;
2097 VS_FIXEDFILEINFO *ffi;
2098 USHORT *lang;
2099 UINT puLen;
2100 WCHAR tmp[32];
2101
2102 TRACE("%s %p %d %p %d\n", debugstr_w(szFilePath),
2103 lpVersionBuf, pcchVersionBuf?*pcchVersionBuf:0,
2104 lpLangBuf, pcchLangBuf?*pcchLangBuf:0);
2105
2106 if ((lpVersionBuf && !pcchVersionBuf) ||
2107 (lpLangBuf && !pcchLangBuf))
2108 return ERROR_INVALID_PARAMETER;
2109
2110 dwVerLen = GetFileVersionInfoSizeW(szFilePath, NULL);
2111 if( !dwVerLen )
2112 {
2113 gle = GetLastError();
2114 if (gle == ERROR_BAD_PATHNAME)
2115 return ERROR_FILE_NOT_FOUND;
2116 else if (gle == ERROR_RESOURCE_DATA_NOT_FOUND)
2117 return ERROR_FILE_INVALID;
2118
2119 return gle;
2120 }
2121
2122 lpVer = msi_alloc(dwVerLen);
2123 if( !lpVer )
2124 {
2125 ret = ERROR_OUTOFMEMORY;
2126 goto end;
2127 }
2128
2129 if( !GetFileVersionInfoW(szFilePath, 0, dwVerLen, lpVer) )
2130 {
2131 ret = GetLastError();
2132 goto end;
2133 }
2134
2135 if (pcchVersionBuf)
2136 {
2137 if( VerQueryValueW(lpVer, szVersionResource, (LPVOID*)&ffi, &puLen) &&
2138 (puLen > 0) )
2139 {
2140 wsprintfW(tmp, szVersionFormat,
2141 HIWORD(ffi->dwFileVersionMS), LOWORD(ffi->dwFileVersionMS),
2142 HIWORD(ffi->dwFileVersionLS), LOWORD(ffi->dwFileVersionLS));
2143 if (lpVersionBuf) lstrcpynW(lpVersionBuf, tmp, *pcchVersionBuf);
2144
2145 if (strlenW(tmp) >= *pcchVersionBuf)
2146 ret = ERROR_MORE_DATA;
2147
2148 *pcchVersionBuf = lstrlenW(tmp);
2149 }
2150 else
2151 {
2152 if (lpVersionBuf) *lpVersionBuf = 0;
2153 *pcchVersionBuf = 0;
2154 }
2155 }
2156
2157 if (pcchLangBuf)
2158 {
2159 if (VerQueryValueW(lpVer, szLangResource, (LPVOID*)&lang, &puLen) &&
2160 (puLen > 0))
2161 {
2162 wsprintfW(tmp, szLangFormat, *lang);
2163 if (lpLangBuf) lstrcpynW(lpLangBuf, tmp, *pcchLangBuf);
2164
2165 if (strlenW(tmp) >= *pcchLangBuf)
2166 ret = ERROR_MORE_DATA;
2167
2168 *pcchLangBuf = lstrlenW(tmp);
2169 }
2170 else
2171 {
2172 if (lpLangBuf) *lpLangBuf = 0;
2173 *pcchLangBuf = 0;
2174 }
2175 }
2176
2177 end:
2178 msi_free(lpVer);
2179 return ret;
2180 }
2181
2182 /***********************************************************************
2183 * MsiGetFeatureUsageW [MSI.@]
2184 */
2185 UINT WINAPI MsiGetFeatureUsageW( LPCWSTR szProduct, LPCWSTR szFeature,
2186 LPDWORD pdwUseCount, LPWORD pwDateUsed )
2187 {
2188 FIXME("%s %s %p %p\n",debugstr_w(szProduct), debugstr_w(szFeature),
2189 pdwUseCount, pwDateUsed);
2190 return ERROR_CALL_NOT_IMPLEMENTED;
2191 }
2192
2193 /***********************************************************************
2194 * MsiGetFeatureUsageA [MSI.@]
2195 */
2196 UINT WINAPI MsiGetFeatureUsageA( LPCSTR szProduct, LPCSTR szFeature,
2197 LPDWORD pdwUseCount, LPWORD pwDateUsed )
2198 {
2199 LPWSTR prod = NULL, feat = NULL;
2200 UINT ret = ERROR_OUTOFMEMORY;
2201
2202 TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szFeature),
2203 pdwUseCount, pwDateUsed);
2204
2205 prod = strdupAtoW( szProduct );
2206 if (szProduct && !prod)
2207 goto end;
2208
2209 feat = strdupAtoW( szFeature );
2210 if (szFeature && !feat)
2211 goto end;
2212
2213 ret = MsiGetFeatureUsageW( prod, feat, pdwUseCount, pwDateUsed );
2214
2215 end:
2216 msi_free( prod );
2217 msi_free( feat );
2218
2219 return ret;
2220 }
2221
2222 /***********************************************************************
2223 * MsiUseFeatureExW [MSI.@]
2224 */
2225 INSTALLSTATE WINAPI MsiUseFeatureExW( LPCWSTR szProduct, LPCWSTR szFeature,
2226 DWORD dwInstallMode, DWORD dwReserved )
2227 {
2228 INSTALLSTATE state;
2229
2230 TRACE("%s %s %i %i\n", debugstr_w(szProduct), debugstr_w(szFeature),
2231 dwInstallMode, dwReserved);
2232
2233 state = MsiQueryFeatureStateW( szProduct, szFeature );
2234
2235 if (dwReserved)
2236 return INSTALLSTATE_INVALIDARG;
2237
2238 if (state == INSTALLSTATE_LOCAL && dwInstallMode != INSTALLMODE_NODETECTION)
2239 {
2240 FIXME("mark product %s feature %s as used\n",
2241 debugstr_w(szProduct), debugstr_w(szFeature) );
2242 }
2243
2244 return state;
2245 }
2246
2247 /***********************************************************************
2248 * MsiUseFeatureExA [MSI.@]
2249 */
2250 INSTALLSTATE WINAPI MsiUseFeatureExA( LPCSTR szProduct, LPCSTR szFeature,
2251 DWORD dwInstallMode, DWORD dwReserved )
2252 {
2253 INSTALLSTATE ret = INSTALLSTATE_UNKNOWN;
2254 LPWSTR prod = NULL, feat = NULL;
2255
2256 TRACE("%s %s %i %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
2257 dwInstallMode, dwReserved);
2258
2259 prod = strdupAtoW( szProduct );
2260 if (szProduct && !prod)
2261 goto end;
2262
2263 feat = strdupAtoW( szFeature );
2264 if (szFeature && !feat)
2265 goto end;
2266
2267 ret = MsiUseFeatureExW( prod, feat, dwInstallMode, dwReserved );
2268
2269 end:
2270 msi_free( prod );
2271 msi_free( feat );
2272
2273 return ret;
2274 }
2275
2276 /***********************************************************************
2277 * MsiUseFeatureW [MSI.@]
2278 */
2279 INSTALLSTATE WINAPI MsiUseFeatureW( LPCWSTR szProduct, LPCWSTR szFeature )
2280 {
2281 return MsiUseFeatureExW(szProduct, szFeature, 0, 0);
2282 }
2283
2284 /***********************************************************************
2285 * MsiUseFeatureA [MSI.@]
2286 */
2287 INSTALLSTATE WINAPI MsiUseFeatureA( LPCSTR szProduct, LPCSTR szFeature )
2288 {
2289 return MsiUseFeatureExA(szProduct, szFeature, 0, 0);
2290 }
2291
2292 /***********************************************************************
2293 * MSI_ProvideQualifiedComponentEx [internal]
2294 */
2295 static UINT WINAPI MSI_ProvideQualifiedComponentEx(LPCWSTR szComponent,
2296 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
2297 DWORD Unused1, DWORD Unused2, awstring *lpPathBuf,
2298 LPDWORD pcchPathBuf)
2299 {
2300 WCHAR product[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1],
2301 feature[MAX_FEATURE_CHARS+1];
2302 LPWSTR info;
2303 HKEY hkey;
2304 DWORD sz;
2305 UINT rc;
2306
2307 TRACE("%s %s %i %s %i %i %p %p\n", debugstr_w(szComponent),
2308 debugstr_w(szQualifier), dwInstallMode, debugstr_w(szProduct),
2309 Unused1, Unused2, lpPathBuf, pcchPathBuf);
2310
2311 rc = MSIREG_OpenUserComponentsKey(szComponent, &hkey, FALSE);
2312 if (rc != ERROR_SUCCESS)
2313 return ERROR_INDEX_ABSENT;
2314
2315 info = msi_reg_get_val_str( hkey, szQualifier );
2316 RegCloseKey(hkey);
2317
2318 if (!info)
2319 return ERROR_INDEX_ABSENT;
2320
2321 MsiDecomposeDescriptorW(info, product, feature, component, &sz);
2322
2323 if (!szProduct)
2324 rc = MSI_GetComponentPath(product, component, lpPathBuf, pcchPathBuf);
2325 else
2326 rc = MSI_GetComponentPath(szProduct, component, lpPathBuf, pcchPathBuf);
2327
2328 msi_free( info );
2329
2330 if (rc != INSTALLSTATE_LOCAL)
2331 return ERROR_FILE_NOT_FOUND;
2332
2333 return ERROR_SUCCESS;
2334 }
2335
2336 /***********************************************************************
2337 * MsiProvideQualifiedComponentExW [MSI.@]
2338 */
2339 UINT WINAPI MsiProvideQualifiedComponentExW(LPCWSTR szComponent,
2340 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
2341 DWORD Unused1, DWORD Unused2, LPWSTR lpPathBuf,
2342 LPDWORD pcchPathBuf)
2343 {
2344 awstring path;
2345
2346 path.unicode = TRUE;
2347 path.str.w = lpPathBuf;
2348
2349 return MSI_ProvideQualifiedComponentEx(szComponent, szQualifier,
2350 dwInstallMode, szProduct, Unused1, Unused2, &path, pcchPathBuf);
2351 }
2352
2353 /***********************************************************************
2354 * MsiProvideQualifiedComponentExA [MSI.@]
2355 */
2356 UINT WINAPI MsiProvideQualifiedComponentExA(LPCSTR szComponent,
2357 LPCSTR szQualifier, DWORD dwInstallMode, LPCSTR szProduct,
2358 DWORD Unused1, DWORD Unused2, LPSTR lpPathBuf,
2359 LPDWORD pcchPathBuf)
2360 {
2361 LPWSTR szwComponent, szwQualifier = NULL, szwProduct = NULL;
2362 UINT r = ERROR_OUTOFMEMORY;
2363 awstring path;
2364
2365 TRACE("%s %s %u %s %u %u %p %p\n", debugstr_a(szComponent),
2366 debugstr_a(szQualifier), dwInstallMode, debugstr_a(szProduct),
2367 Unused1, Unused2, lpPathBuf, pcchPathBuf);
2368
2369 szwComponent = strdupAtoW( szComponent );
2370 if (szComponent && !szwComponent)
2371 goto end;
2372
2373 szwQualifier = strdupAtoW( szQualifier );
2374 if (szQualifier && !szwQualifier)
2375 goto end;
2376
2377 szwProduct = strdupAtoW( szProduct );
2378 if (szProduct && !szwProduct)
2379 goto end;
2380
2381 path.unicode = FALSE;
2382 path.str.a = lpPathBuf;
2383
2384 r = MSI_ProvideQualifiedComponentEx(szwComponent, szwQualifier,
2385 dwInstallMode, szwProduct, Unused1,
2386 Unused2, &path, pcchPathBuf);
2387 end:
2388 msi_free(szwProduct);
2389 msi_free(szwComponent);
2390 msi_free(szwQualifier);
2391
2392 return r;
2393 }
2394
2395 /***********************************************************************
2396 * MsiProvideQualifiedComponentW [MSI.@]
2397 */
2398 UINT WINAPI MsiProvideQualifiedComponentW( LPCWSTR szComponent,
2399 LPCWSTR szQualifier, DWORD dwInstallMode, LPWSTR lpPathBuf,
2400 LPDWORD pcchPathBuf)
2401 {
2402 return MsiProvideQualifiedComponentExW(szComponent, szQualifier,
2403 dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
2404 }
2405
2406 /***********************************************************************
2407 * MsiProvideQualifiedComponentA [MSI.@]
2408 */
2409 UINT WINAPI MsiProvideQualifiedComponentA( LPCSTR szComponent,
2410 LPCSTR szQualifier, DWORD dwInstallMode, LPSTR lpPathBuf,
2411 LPDWORD pcchPathBuf)
2412 {
2413 return MsiProvideQualifiedComponentExA(szComponent, szQualifier,
2414 dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
2415 }
2416
2417 /***********************************************************************
2418 * MSI_GetUserInfo [internal]
2419 */
2420 static USERINFOSTATE WINAPI MSI_GetUserInfo(LPCWSTR szProduct,
2421 awstring *lpUserNameBuf, LPDWORD pcchUserNameBuf,
2422 awstring *lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
2423 awstring *lpSerialBuf, LPDWORD pcchSerialBuf)
2424 {
2425 WCHAR squished_pc[SQUISH_GUID_SIZE];
2426 LPWSTR user, org, serial;
2427 USERINFOSTATE state;
2428 HKEY hkey, props;
2429 LPCWSTR orgptr;
2430 UINT r;
2431
2432 static const WCHAR szEmpty[] = {0};
2433
2434 TRACE("%s %p %p %p %p %p %p\n", debugstr_w(szProduct), lpUserNameBuf,
2435 pcchUserNameBuf, lpOrgNameBuf, pcchOrgNameBuf, lpSerialBuf,
2436 pcchSerialBuf);
2437
2438 if (!szProduct || !squash_guid(szProduct, squished_pc))
2439 return USERINFOSTATE_INVALIDARG;
2440
2441 if (MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_USERMANAGED,
2442 &hkey, FALSE) != ERROR_SUCCESS &&
2443 MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
2444 &hkey, FALSE) != ERROR_SUCCESS &&
2445 MSIREG_OpenProductKey(szProduct, MSIINSTALLCONTEXT_MACHINE,
2446 &hkey, FALSE) != ERROR_SUCCESS)
2447 {
2448 return USERINFOSTATE_UNKNOWN;
2449 }
2450
2451 if (MSIREG_OpenCurrentUserInstallProps(szProduct, &props, FALSE) != ERROR_SUCCESS &&
2452 MSIREG_OpenLocalSystemInstallProps(szProduct, &props, FALSE) != ERROR_SUCCESS)
2453 {
2454 RegCloseKey(hkey);
2455 return USERINFOSTATE_ABSENT;
2456 }
2457
2458 user = msi_reg_get_val_str(props, INSTALLPROPERTY_REGOWNERW);
2459 org = msi_reg_get_val_str(props, INSTALLPROPERTY_REGCOMPANYW);
2460 serial = msi_reg_get_val_str(props, INSTALLPROPERTY_PRODUCTIDW);
2461 state = USERINFOSTATE_ABSENT;
2462
2463 RegCloseKey(hkey);
2464 RegCloseKey(props);
2465
2466 if (user && serial)
2467 state = USERINFOSTATE_PRESENT;
2468
2469 if (pcchUserNameBuf)
2470 {
2471 if (lpUserNameBuf && !user)
2472 {
2473 (*pcchUserNameBuf)--;
2474 goto done;
2475 }
2476
2477 r = msi_strcpy_to_awstring(user, lpUserNameBuf, pcchUserNameBuf);
2478 if (r == ERROR_MORE_DATA)
2479 {
2480 state = USERINFOSTATE_MOREDATA;
2481 goto done;
2482 }
2483 }
2484
2485 if (pcchOrgNameBuf)
2486 {
2487 orgptr = org;
2488 if (!orgptr) orgptr = szEmpty;
2489
2490 r = msi_strcpy_to_awstring(orgptr, lpOrgNameBuf, pcchOrgNameBuf);
2491 if (r == ERROR_MORE_DATA)
2492 {
2493 state = USERINFOSTATE_MOREDATA;
2494 goto done;
2495 }
2496 }
2497
2498 if (pcchSerialBuf)
2499 {
2500 if (!serial)
2501 {
2502 (*pcchSerialBuf)--;
2503 goto done;
2504 }
2505
2506 r = msi_strcpy_to_awstring(serial, lpSerialBuf, pcchSerialBuf);
2507 if (r == ERROR_MORE_DATA)
2508 state = USERINFOSTATE_MOREDATA;
2509 }
2510
2511 done:
2512 msi_free(user);
2513 msi_free(org);
2514 msi_free(serial);
2515
2516 return state;
2517 }
2518
2519 /***********************************************************************
2520 * MsiGetUserInfoW [MSI.@]
2521 */
2522 USERINFOSTATE WINAPI MsiGetUserInfoW(LPCWSTR szProduct,
2523 LPWSTR lpUserNameBuf, LPDWORD pcchUserNameBuf,
2524 LPWSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
2525 LPWSTR lpSerialBuf, LPDWORD pcchSerialBuf)
2526 {
2527 awstring user, org, serial;
2528
2529 if ((lpUserNameBuf && !pcchUserNameBuf) ||
2530 (lpOrgNameBuf && !pcchOrgNameBuf) ||
2531 (lpSerialBuf && !pcchSerialBuf))
2532 return USERINFOSTATE_INVALIDARG;
2533
2534 user.unicode = TRUE;
2535 user.str.w = lpUserNameBuf;
2536 org.unicode = TRUE;
2537 org.str.w = lpOrgNameBuf;
2538 serial.unicode = TRUE;
2539 serial.str.w = lpSerialBuf;
2540
2541 return MSI_GetUserInfo( szProduct, &user, pcchUserNameBuf,
2542 &org, pcchOrgNameBuf,
2543 &serial, pcchSerialBuf );
2544 }
2545
2546 USERINFOSTATE WINAPI MsiGetUserInfoA(LPCSTR szProduct,
2547 LPSTR lpUserNameBuf, LPDWORD pcchUserNameBuf,
2548 LPSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
2549 LPSTR lpSerialBuf, LPDWORD pcchSerialBuf)
2550 {
2551 awstring user, org, serial;
2552 LPWSTR prod;
2553 UINT r;
2554
2555 if ((lpUserNameBuf && !pcchUserNameBuf) ||
2556 (lpOrgNameBuf && !pcchOrgNameBuf) ||
2557 (lpSerialBuf && !pcchSerialBuf))
2558 return USERINFOSTATE_INVALIDARG;
2559
2560 prod = strdupAtoW( szProduct );
2561 if (szProduct && !prod)
2562 return ERROR_OUTOFMEMORY;
2563
2564 user.unicode = FALSE;
2565 user.str.a = lpUserNameBuf;
2566 org.unicode = FALSE;
2567 org.str.a = lpOrgNameBuf;
2568 serial.unicode = FALSE;
2569 serial.str.a = lpSerialBuf;
2570
2571 r = MSI_GetUserInfo( prod, &user, pcchUserNameBuf,
2572 &org, pcchOrgNameBuf,
2573 &serial, pcchSerialBuf );
2574
2575 msi_free( prod );
2576
2577 return r;
2578 }
2579
2580 UINT WINAPI MsiCollectUserInfoW(LPCWSTR szProduct)
2581 {
2582 MSIHANDLE handle;
2583 UINT rc;
2584 MSIPACKAGE *package;
2585 static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
2586
2587 TRACE("(%s)\n",debugstr_w(szProduct));
2588
2589 rc = MsiOpenProductW(szProduct,&handle);
2590 if (rc != ERROR_SUCCESS)
2591 return ERROR_INVALID_PARAMETER;
2592
2593 package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
2594 rc = ACTION_PerformUIAction(package, szFirstRun, -1);
2595 msiobj_release( &package->hdr );
2596
2597 MsiCloseHandle(handle);
2598
2599 return rc;
2600 }
2601
2602 UINT WINAPI MsiCollectUserInfoA(LPCSTR szProduct)
2603 {
2604 MSIHANDLE handle;
2605 UINT rc;
2606 MSIPACKAGE *package;
2607 static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
2608
2609 TRACE("(%s)\n",debugstr_a(szProduct));
2610
2611 rc = MsiOpenProductA(szProduct,&handle);
2612 if (rc != ERROR_SUCCESS)
2613 return ERROR_INVALID_PARAMETER;
2614
2615 package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
2616 rc = ACTION_PerformUIAction(package, szFirstRun, -1);
2617 msiobj_release( &package->hdr );
2618
2619 MsiCloseHandle(handle);
2620
2621 return rc;
2622 }
2623
2624 /***********************************************************************
2625 * MsiConfigureFeatureA [MSI.@]
2626 */
2627 UINT WINAPI MsiConfigureFeatureA(LPCSTR szProduct, LPCSTR szFeature, INSTALLSTATE eInstallState)
2628 {
2629 LPWSTR prod, feat = NULL;
2630 UINT r = ERROR_OUTOFMEMORY;
2631
2632 TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature), eInstallState);
2633
2634 prod = strdupAtoW( szProduct );
2635 if (szProduct && !prod)
2636 goto end;
2637
2638 feat = strdupAtoW( szFeature );
2639 if (szFeature && !feat)
2640 goto end;
2641
2642 r = MsiConfigureFeatureW(prod, feat, eInstallState);
2643
2644 end:
2645 msi_free(feat);
2646 msi_free(prod);
2647
2648 return r;
2649 }
2650
2651 /***********************************************************************
2652 * MsiConfigureFeatureW [MSI.@]
2653 */
2654 UINT WINAPI MsiConfigureFeatureW(LPCWSTR szProduct, LPCWSTR szFeature, INSTALLSTATE eInstallState)
2655 {
2656 static const WCHAR szCostInit[] = { 'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0 };
2657 MSIPACKAGE *package = NULL;
2658 UINT r;
2659 WCHAR sourcepath[MAX_PATH], filename[MAX_PATH];
2660 DWORD sz;
2661
2662 TRACE("%s %s %i\n", debugstr_w(szProduct), debugstr_w(szFeature), eInstallState);
2663
2664 if (!szProduct || !szFeature)
2665 return ERROR_INVALID_PARAMETER;
2666
2667 switch (eInstallState)
2668 {
2669 case INSTALLSTATE_DEFAULT:
2670 /* FIXME: how do we figure out the default location? */
2671 eInstallState = INSTALLSTATE_LOCAL;
2672 break;
2673 case INSTALLSTATE_LOCAL:
2674 case INSTALLSTATE_SOURCE:
2675 case INSTALLSTATE_ABSENT:
2676 case INSTALLSTATE_ADVERTISED:
2677 break;
2678 default:
2679 return ERROR_INVALID_PARAMETER;
2680 }
2681
2682 r = MSI_OpenProductW( szProduct, &package );
2683 if (r != ERROR_SUCCESS)
2684 return r;
2685
2686 sz = sizeof(sourcepath);
2687 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2688 MSICODE_PRODUCT, INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
2689
2690 sz = sizeof(filename);
2691 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2692 MSICODE_PRODUCT, INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
2693
2694 lstrcatW( sourcepath, filename );
2695
2696 MsiSetInternalUI( INSTALLUILEVEL_BASIC, NULL );
2697
2698 r = ACTION_PerformUIAction( package, szCostInit, -1 );
2699 if (r != ERROR_SUCCESS)
2700 goto end;
2701
2702 r = MSI_SetFeatureStateW( package, szFeature, eInstallState);
2703 if (r != ERROR_SUCCESS)
2704 goto end;
2705
2706 r = MSI_InstallPackage( package, sourcepath, NULL );
2707
2708 end:
2709 msiobj_release( &package->hdr );
2710
2711 return r;
2712 }
2713
2714 /***********************************************************************
2715 * MsiCreateAndVerifyInstallerDirectory [MSI.@]
2716 *
2717 * Notes: undocumented
2718 */
2719 UINT WINAPI MsiCreateAndVerifyInstallerDirectory(DWORD dwReserved)
2720 {
2721 WCHAR path[MAX_PATH];
2722
2723 TRACE("%d\n", dwReserved);
2724
2725 if (dwReserved)
2726 {
2727 FIXME("dwReserved=%d\n", dwReserved);
2728 return ERROR_INVALID_PARAMETER;
2729 }
2730
2731 if (!GetWindowsDirectoryW(path, MAX_PATH))
2732 return ERROR_FUNCTION_FAILED;
2733
2734 lstrcatW(path, installerW);
2735
2736 if (!CreateDirectoryW(path, NULL))
2737 return ERROR_FUNCTION_FAILED;
2738
2739 return ERROR_SUCCESS;
2740 }
2741
2742 /***********************************************************************
2743 * MsiGetShortcutTargetA [MSI.@]
2744 */
2745 UINT WINAPI MsiGetShortcutTargetA( LPCSTR szShortcutTarget,
2746 LPSTR szProductCode, LPSTR szFeatureId,
2747 LPSTR szComponentCode )
2748 {
2749 LPWSTR target;
2750 const int len = MAX_FEATURE_CHARS+1;
2751 WCHAR product[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1];
2752 UINT r;
2753
2754 target = strdupAtoW( szShortcutTarget );
2755 if (szShortcutTarget && !target )
2756 return ERROR_OUTOFMEMORY;
2757 product[0] = 0;
2758 feature[0] = 0;
2759 component[0] = 0;
2760 r = MsiGetShortcutTargetW( target, product, feature, component );
2761 msi_free( target );
2762 if (r == ERROR_SUCCESS)
2763 {
2764 WideCharToMultiByte( CP_ACP, 0, product, -1, szProductCode, len, NULL, NULL );
2765 WideCharToMultiByte( CP_ACP, 0, feature, -1, szFeatureId, len, NULL, NULL );
2766 WideCharToMultiByte( CP_ACP, 0, component, -1, szComponentCode, len, NULL, NULL );
2767 }
2768 return r;
2769 }
2770
2771 /***********************************************************************
2772 * MsiGetShortcutTargetW [MSI.@]
2773 */
2774 UINT WINAPI MsiGetShortcutTargetW( LPCWSTR szShortcutTarget,
2775 LPWSTR szProductCode, LPWSTR szFeatureId,
2776 LPWSTR szComponentCode )
2777 {
2778 IShellLinkDataList *dl = NULL;
2779 IPersistFile *pf = NULL;
2780 LPEXP_DARWIN_LINK darwin = NULL;
2781 HRESULT r, init;
2782
2783 TRACE("%s %p %p %p\n", debugstr_w(szShortcutTarget),
2784 szProductCode, szFeatureId, szComponentCode );
2785
2786 init = CoInitialize(NULL);
2787
2788 r = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
2789 &IID_IPersistFile, (LPVOID*) &pf );
2790 if( SUCCEEDED( r ) )
2791 {
2792 r = IPersistFile_Load( pf, szShortcutTarget,
2793 STGM_READ | STGM_SHARE_DENY_WRITE );
2794 if( SUCCEEDED( r ) )
2795 {
2796 r = IPersistFile_QueryInterface( pf, &IID_IShellLinkDataList,
2797 (LPVOID*) &dl );
2798 if( SUCCEEDED( r ) )
2799 {
2800 IShellLinkDataList_CopyDataBlock( dl, EXP_DARWIN_ID_SIG,
2801 (LPVOID) &darwin );
2802 IShellLinkDataList_Release( dl );
2803 }
2804 }
2805 IPersistFile_Release( pf );
2806 }
2807
2808 if (SUCCEEDED(init))
2809 CoUninitialize();
2810
2811 TRACE("darwin = %p\n", darwin);
2812
2813 if (darwin)
2814 {
2815 DWORD sz;
2816 UINT ret;
2817
2818 ret = MsiDecomposeDescriptorW( darwin->szwDarwinID,
2819 szProductCode, szFeatureId, szComponentCode, &sz );
2820 LocalFree( darwin );
2821 return ret;
2822 }
2823
2824 return ERROR_FUNCTION_FAILED;
2825 }
2826
2827 UINT WINAPI MsiReinstallFeatureW( LPCWSTR szProduct, LPCWSTR szFeature,
2828 DWORD dwReinstallMode )
2829 {
2830 MSIPACKAGE* package = NULL;
2831 UINT r;
2832 WCHAR sourcepath[MAX_PATH];
2833 WCHAR filename[MAX_PATH];
2834 static const WCHAR szLogVerbose[] = {
2835 ' ','L','O','G','V','E','R','B','O','S','E',0 };
2836 static const WCHAR szInstalled[] = { 'I','n','s','t','a','l','l','e','d',0};
2837 static const WCHAR szReinstall[] = {'R','E','I','N','S','T','A','L','L',0};
2838 static const WCHAR szReinstallMode[] = {'R','E','I','N','S','T','A','L','L','M','O','D','E',0};
2839 static const WCHAR szOne[] = {'1',0};
2840 WCHAR reinstallmode[11];
2841 LPWSTR ptr;
2842 DWORD sz;
2843
2844 FIXME("%s %s %i\n", debugstr_w(szProduct), debugstr_w(szFeature),
2845 dwReinstallMode);
2846
2847 ptr = reinstallmode;
2848
2849 if (dwReinstallMode & REINSTALLMODE_FILEMISSING)
2850 *ptr++ = 'p';
2851 if (dwReinstallMode & REINSTALLMODE_FILEOLDERVERSION)
2852 *ptr++ = 'o';
2853 if (dwReinstallMode & REINSTALLMODE_FILEEQUALVERSION)
2854 *ptr++ = 'w';
2855 if (dwReinstallMode & REINSTALLMODE_FILEEXACT)
2856 *ptr++ = 'd';
2857 if (dwReinstallMode & REINSTALLMODE_FILEVERIFY)
2858 *ptr++ = 'c';
2859 if (dwReinstallMode & REINSTALLMODE_FILEREPLACE)
2860 *ptr++ = 'a';
2861 if (dwReinstallMode & REINSTALLMODE_USERDATA)
2862 *ptr++ = 'u';
2863 if (dwReinstallMode & REINSTALLMODE_MACHINEDATA)
2864 *ptr++ = 'm';
2865 if (dwReinstallMode & REINSTALLMODE_SHORTCUT)
2866 *ptr++ = 's';
2867 if (dwReinstallMode & REINSTALLMODE_PACKAGE)
2868 *ptr++ = 'v';
2869 *ptr = 0;
2870
2871 sz = sizeof(sourcepath);
2872 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2873 MSICODE_PRODUCT, INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
2874
2875 sz = sizeof(filename);
2876 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2877 MSICODE_PRODUCT, INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
2878
2879 lstrcatW( sourcepath, filename );
2880
2881 if (dwReinstallMode & REINSTALLMODE_PACKAGE)
2882 r = MSI_OpenPackageW( sourcepath, &package );
2883 else
2884 r = MSI_OpenProductW( szProduct, &package );
2885
2886 if (r != ERROR_SUCCESS)
2887 return r;
2888
2889 MSI_SetPropertyW( package, szReinstallMode, reinstallmode );
2890 MSI_SetPropertyW( package, szInstalled, szOne );
2891 MSI_SetPropertyW( package, szLogVerbose, szOne );
2892 MSI_SetPropertyW( package, szReinstall, szFeature );
2893
2894 r = MSI_InstallPackage( package, sourcepath, NULL );
2895
2896 msiobj_release( &package->hdr );
2897
2898 return r;
2899 }
2900
2901 UINT WINAPI MsiReinstallFeatureA( LPCSTR szProduct, LPCSTR szFeature,
2902 DWORD dwReinstallMode )
2903 {
2904 LPWSTR wszProduct;
2905 LPWSTR wszFeature;
2906 UINT rc;
2907
2908 TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
2909 dwReinstallMode);
2910
2911 wszProduct = strdupAtoW(szProduct);
2912 wszFeature = strdupAtoW(szFeature);
2913
2914 rc = MsiReinstallFeatureW(wszProduct, wszFeature, dwReinstallMode);
2915
2916 msi_free(wszProduct);
2917 msi_free(wszFeature);
2918 return rc;
2919 }
2920
2921 typedef struct
2922 {
2923 unsigned int i[2];
2924 unsigned int buf[4];
2925 unsigned char in[64];
2926 unsigned char digest[16];
2927 } MD5_CTX;
2928
2929 extern VOID WINAPI MD5Init( MD5_CTX *);
2930 extern VOID WINAPI MD5Update( MD5_CTX *, const unsigned char *, unsigned int );
2931 extern VOID WINAPI MD5Final( MD5_CTX *);
2932
2933 /***********************************************************************
2934 * MsiGetFileHashW [MSI.@]
2935 */
2936 UINT WINAPI MsiGetFileHashW( LPCWSTR szFilePath, DWORD dwOptions,
2937 PMSIFILEHASHINFO pHash )
2938 {
2939 HANDLE handle, mapping;
2940 void *p;
2941 DWORD length;
2942 UINT r = ERROR_FUNCTION_FAILED;
2943
2944 TRACE("%s %08x %p\n", debugstr_w(szFilePath), dwOptions, pHash );
2945
2946 if (!szFilePath)
2947 return ERROR_INVALID_PARAMETER;
2948
2949 if (!*szFilePath)
2950 return ERROR_PATH_NOT_FOUND;
2951
2952 if (dwOptions)
2953 return ERROR_INVALID_PARAMETER;
2954 if (!pHash)
2955 return ERROR_INVALID_PARAMETER;
2956 if (pHash->dwFileHashInfoSize < sizeof *pHash)
2957 return ERROR_INVALID_PARAMETER;
2958
2959 handle = CreateFileW( szFilePath, GENERIC_READ,
2960 FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, NULL );
2961 if (handle == INVALID_HANDLE_VALUE)
2962 return ERROR_FILE_NOT_FOUND;
2963
2964 length = GetFileSize( handle, NULL );
2965
2966 mapping = CreateFileMappingW( handle, NULL, PAGE_READONLY, 0, 0, NULL );
2967 if (mapping)
2968 {
2969 p = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, length );
2970 if (p)
2971 {
2972 MD5_CTX ctx;
2973
2974 MD5Init( &ctx );
2975 MD5Update( &ctx, p, length );
2976 MD5Final( &ctx );
2977 UnmapViewOfFile( p );
2978
2979 memcpy( pHash->dwData, ctx.digest, sizeof pHash->dwData );
2980 r = ERROR_SUCCESS;
2981 }
2982 CloseHandle( mapping );
2983 }
2984 CloseHandle( handle );
2985
2986 return r;
2987 }
2988
2989 /***********************************************************************
2990 * MsiGetFileHashA [MSI.@]
2991 */
2992 UINT WINAPI MsiGetFileHashA( LPCSTR szFilePath, DWORD dwOptions,
2993 PMSIFILEHASHINFO pHash )
2994 {
2995 LPWSTR file;
2996 UINT r;
2997
2998 TRACE("%s %08x %p\n", debugstr_a(szFilePath), dwOptions, pHash );
2999
3000 file = strdupAtoW( szFilePath );
3001 if (szFilePath && !file)
3002 return ERROR_OUTOFMEMORY;
3003
3004 r = MsiGetFileHashW( file, dwOptions, pHash );
3005 msi_free( file );
3006 return r;
3007 }
3008
3009 /***********************************************************************
3010 * MsiAdvertiseScriptW [MSI.@]
3011 */
3012 UINT WINAPI MsiAdvertiseScriptW( LPCWSTR szScriptFile, DWORD dwFlags,
3013 PHKEY phRegData, BOOL fRemoveItems )
3014 {
3015 FIXME("%s %08x %p %d\n",
3016 debugstr_w( szScriptFile ), dwFlags, phRegData, fRemoveItems );
3017 return ERROR_CALL_NOT_IMPLEMENTED;
3018 }
3019
3020 /***********************************************************************
3021 * MsiAdvertiseScriptA [MSI.@]
3022 */
3023 UINT WINAPI MsiAdvertiseScriptA( LPCSTR szScriptFile, DWORD dwFlags,
3024 PHKEY phRegData, BOOL fRemoveItems )
3025 {
3026 FIXME("%s %08x %p %d\n",
3027 debugstr_a( szScriptFile ), dwFlags, phRegData, fRemoveItems );
3028 return ERROR_CALL_NOT_IMPLEMENTED;
3029 }
3030
3031 /***********************************************************************
3032 * MsiIsProductElevatedW [MSI.@]
3033 */
3034 UINT WINAPI MsiIsProductElevatedW( LPCWSTR szProduct, BOOL *pfElevated )
3035 {
3036 FIXME("%s %p - stub\n",
3037 debugstr_w( szProduct ), pfElevated );
3038 *pfElevated = TRUE;
3039 return ERROR_SUCCESS;
3040 }
3041
3042 /***********************************************************************
3043 * MsiIsProductElevatedA [MSI.@]
3044 */
3045 UINT WINAPI MsiIsProductElevatedA( LPCSTR szProduct, BOOL *pfElevated )
3046 {
3047 FIXME("%s %p - stub\n",
3048 debugstr_a( szProduct ), pfElevated );
3049 *pfElevated = TRUE;
3050 return ERROR_SUCCESS;
3051 }
3052
3053 /***********************************************************************
3054 * MsiSetExternalUIRecord [MSI.@]
3055 */
3056 UINT WINAPI MsiSetExternalUIRecord( INSTALLUI_HANDLER_RECORD puiHandler,
3057 DWORD dwMessageFilter, LPVOID pvContext,
3058 PINSTALLUI_HANDLER_RECORD ppuiPrevHandler)
3059 {
3060 FIXME("%p %08x %p %p\n", puiHandler, dwMessageFilter ,pvContext,
3061 ppuiPrevHandler);
3062 return ERROR_CALL_NOT_IMPLEMENTED;
3063 }
3064
3065 /***********************************************************************
3066 * MsiInstallMissingComponentW [MSI.@]
3067 */
3068 UINT WINAPI MsiInstallMissingComponentW(LPCWSTR szProduct, LPCWSTR szComponent, INSTALLSTATE eInstallState)
3069 {
3070 FIXME("(%s %s %d\n", debugstr_w(szProduct), debugstr_w(szComponent), eInstallState);
3071 return ERROR_SUCCESS;
3072 }
useful hacks and other patches not (yet) suitable for mainline