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