sync msi with wine 1.1.35
[reactos.git] / reactos / dll / win32 / msi / msi.c
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 MsiEnableLogA(DWORD dwLogMode, LPCSTR szLogFile, DWORD attributes)
1617 {
1618 LPWSTR szwLogFile = NULL;
1619 UINT r;
1620
1621 TRACE("%08x %s %08x\n", dwLogMode, debugstr_a(szLogFile), attributes);
1622
1623 if( szLogFile )
1624 {
1625 szwLogFile = strdupAtoW( szLogFile );
1626 if( !szwLogFile )
1627 return ERROR_OUTOFMEMORY;
1628 }
1629 r = MsiEnableLogW( dwLogMode, szwLogFile, attributes );
1630 msi_free( szwLogFile );
1631 return r;
1632 }
1633
1634 UINT WINAPI MsiEnableLogW(DWORD dwLogMode, LPCWSTR szLogFile, DWORD attributes)
1635 {
1636 HANDLE file = INVALID_HANDLE_VALUE;
1637
1638 TRACE("%08x %s %08x\n", dwLogMode, debugstr_w(szLogFile), attributes);
1639
1640 if (szLogFile)
1641 {
1642 lstrcpyW(gszLogFile,szLogFile);
1643 if (!(attributes & INSTALLLOGATTRIBUTES_APPEND))
1644 DeleteFileW(szLogFile);
1645 file = CreateFileW(szLogFile, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS,
1646 FILE_ATTRIBUTE_NORMAL, NULL);
1647 if (file != INVALID_HANDLE_VALUE)
1648 CloseHandle(file);
1649 else
1650 ERR("Unable to enable log %s\n",debugstr_w(szLogFile));
1651 }
1652 else
1653 gszLogFile[0] = '\0';
1654
1655 return ERROR_SUCCESS;
1656 }
1657
1658 UINT WINAPI MsiEnumComponentCostsW(MSIHANDLE hInstall, LPCWSTR szComponent,
1659 DWORD dwIndex, INSTALLSTATE iState,
1660 LPWSTR lpDriveBuf, DWORD *pcchDriveBuf,
1661 int *piCost, int *pTempCost)
1662 {
1663 FIXME("(%d, %s, %d, %d, %p, %p, %p %p): stub!\n", hInstall,
1664 debugstr_w(szComponent), dwIndex, iState, lpDriveBuf,
1665 pcchDriveBuf, piCost, pTempCost);
1666
1667 return ERROR_NO_MORE_ITEMS;
1668 }
1669
1670 UINT WINAPI MsiQueryComponentStateA(LPCSTR szProductCode,
1671 LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext,
1672 LPCSTR szComponent, INSTALLSTATE *pdwState)
1673 {
1674 LPWSTR prodcode = NULL, usersid = NULL, comp = NULL;
1675 UINT r;
1676
1677 TRACE("(%s, %s, %d, %s, %p)\n", debugstr_a(szProductCode),
1678 debugstr_a(szUserSid), dwContext, debugstr_a(szComponent), pdwState);
1679
1680 if (szProductCode && !(prodcode = strdupAtoW(szProductCode)))
1681 return ERROR_OUTOFMEMORY;
1682
1683 if (szUserSid && !(usersid = strdupAtoW(szUserSid)))
1684 return ERROR_OUTOFMEMORY;
1685
1686 if (szComponent && !(comp = strdupAtoW(szComponent)))
1687 return ERROR_OUTOFMEMORY;
1688
1689 r = MsiQueryComponentStateW(prodcode, usersid, dwContext, comp, pdwState);
1690
1691 msi_free(prodcode);
1692 msi_free(usersid);
1693 msi_free(comp);
1694
1695 return r;
1696 }
1697
1698 static BOOL msi_comp_find_prod_key(LPCWSTR prodcode, MSIINSTALLCONTEXT context)
1699 {
1700 UINT r;
1701 HKEY hkey;
1702
1703 r = MSIREG_OpenProductKey(prodcode, NULL, context, &hkey, FALSE);
1704 RegCloseKey(hkey);
1705 return (r == ERROR_SUCCESS);
1706 }
1707
1708 static BOOL msi_comp_find_package(LPCWSTR prodcode, MSIINSTALLCONTEXT context)
1709 {
1710 LPCWSTR package;
1711 HKEY hkey;
1712 DWORD sz;
1713 LONG res;
1714 UINT r;
1715
1716 static const WCHAR local_package[] = {'L','o','c','a','l','P','a','c','k','a','g','e',0};
1717 static const WCHAR managed_local_package[] = {
1718 'M','a','n','a','g','e','d','L','o','c','a','l','P','a','c','k','a','g','e',0
1719 };
1720
1721 r = MSIREG_OpenInstallProps(prodcode, context, NULL, &hkey, FALSE);
1722 if (r != ERROR_SUCCESS)
1723 return FALSE;
1724
1725 if (context == MSIINSTALLCONTEXT_USERMANAGED)
1726 package = managed_local_package;
1727 else
1728 package = local_package;
1729
1730 sz = 0;
1731 res = RegQueryValueExW(hkey, package, NULL, NULL, NULL, &sz);
1732 RegCloseKey(hkey);
1733
1734 return (res == ERROR_SUCCESS);
1735 }
1736
1737 static BOOL msi_comp_find_prodcode(LPWSTR squished_pc,
1738 MSIINSTALLCONTEXT context,
1739 LPCWSTR comp, LPWSTR val, DWORD *sz)
1740 {
1741 HKEY hkey;
1742 LONG res;
1743 UINT r;
1744
1745 if (context == MSIINSTALLCONTEXT_MACHINE)
1746 r = MSIREG_OpenUserDataComponentKey(comp, szLocalSid, &hkey, FALSE);
1747 else
1748 r = MSIREG_OpenUserDataComponentKey(comp, NULL, &hkey, FALSE);
1749
1750 if (r != ERROR_SUCCESS)
1751 return FALSE;
1752
1753 res = RegQueryValueExW(hkey, squished_pc, NULL, NULL, (BYTE *)val, sz);
1754 if (res != ERROR_SUCCESS)
1755 return FALSE;
1756
1757 RegCloseKey(hkey);
1758 return TRUE;
1759 }
1760
1761 UINT WINAPI MsiQueryComponentStateW(LPCWSTR szProductCode,
1762 LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext,
1763 LPCWSTR szComponent, INSTALLSTATE *pdwState)
1764 {
1765 WCHAR squished_pc[GUID_SIZE];
1766 WCHAR val[MAX_PATH];
1767 BOOL found;
1768 DWORD sz;
1769
1770 TRACE("(%s, %s, %d, %s, %p)\n", debugstr_w(szProductCode),
1771 debugstr_w(szUserSid), dwContext, debugstr_w(szComponent), pdwState);
1772
1773 if (!pdwState || !szComponent)
1774 return ERROR_INVALID_PARAMETER;
1775
1776 if (!szProductCode || !*szProductCode || lstrlenW(szProductCode) != GUID_SIZE - 1)
1777 return ERROR_INVALID_PARAMETER;
1778
1779 if (!squash_guid(szProductCode, squished_pc))
1780 return ERROR_INVALID_PARAMETER;
1781
1782 found = msi_comp_find_prod_key(szProductCode, dwContext);
1783
1784 if (!msi_comp_find_package(szProductCode, dwContext))
1785 {
1786 if (found)
1787 {
1788 *pdwState = INSTALLSTATE_UNKNOWN;
1789 return ERROR_UNKNOWN_COMPONENT;
1790 }
1791
1792 return ERROR_UNKNOWN_PRODUCT;
1793 }
1794
1795 *pdwState = INSTALLSTATE_UNKNOWN;
1796
1797 sz = MAX_PATH;
1798 if (!msi_comp_find_prodcode(squished_pc, dwContext, szComponent, val, &sz))
1799 return ERROR_UNKNOWN_COMPONENT;
1800
1801 if (sz == 0)
1802 *pdwState = INSTALLSTATE_NOTUSED;
1803 else
1804 {
1805 if (lstrlenW(val) > 2 &&
1806 val[0] >= '0' && val[0] <= '9' && val[1] >= '0' && val[1] <= '9')
1807 {
1808 *pdwState = INSTALLSTATE_SOURCE;
1809 }
1810 else
1811 *pdwState = INSTALLSTATE_LOCAL;
1812 }
1813
1814 return ERROR_SUCCESS;
1815 }
1816
1817 INSTALLSTATE WINAPI MsiQueryProductStateA(LPCSTR szProduct)
1818 {
1819 LPWSTR szwProduct = NULL;
1820 INSTALLSTATE r;
1821
1822 if( szProduct )
1823 {
1824 szwProduct = strdupAtoW( szProduct );
1825 if( !szwProduct )
1826 return ERROR_OUTOFMEMORY;
1827 }
1828 r = MsiQueryProductStateW( szwProduct );
1829 msi_free( szwProduct );
1830 return r;
1831 }
1832
1833 INSTALLSTATE WINAPI MsiQueryProductStateW(LPCWSTR szProduct)
1834 {
1835 MSIINSTALLCONTEXT context = MSIINSTALLCONTEXT_USERUNMANAGED;
1836 INSTALLSTATE state = INSTALLSTATE_ADVERTISED;
1837 HKEY prodkey = 0, userdata = 0;
1838 DWORD val;
1839 UINT r;
1840
1841 static const WCHAR szWindowsInstaller[] = {
1842 'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
1843
1844 TRACE("%s\n", debugstr_w(szProduct));
1845
1846 if (!szProduct || !*szProduct)
1847 return INSTALLSTATE_INVALIDARG;
1848
1849 if (lstrlenW(szProduct) != GUID_SIZE - 1)
1850 return INSTALLSTATE_INVALIDARG;
1851
1852 if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
1853 &prodkey, FALSE) != ERROR_SUCCESS &&
1854 MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
1855 &prodkey, FALSE) != ERROR_SUCCESS &&
1856 MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
1857 &prodkey, FALSE) == ERROR_SUCCESS)
1858 {
1859 context = MSIINSTALLCONTEXT_MACHINE;
1860 }
1861
1862 r = MSIREG_OpenInstallProps(szProduct, context, NULL, &userdata, FALSE);
1863 if (r != ERROR_SUCCESS)
1864 goto done;
1865
1866 if (!msi_reg_get_val_dword(userdata, szWindowsInstaller, &val))
1867 goto done;
1868
1869 if (val)
1870 state = INSTALLSTATE_DEFAULT;
1871 else
1872 state = INSTALLSTATE_UNKNOWN;
1873
1874 done:
1875 if (!prodkey)
1876 {
1877 state = INSTALLSTATE_UNKNOWN;
1878
1879 if (userdata)
1880 state = INSTALLSTATE_ABSENT;
1881 }
1882
1883 RegCloseKey(prodkey);
1884 RegCloseKey(userdata);
1885 return state;
1886 }
1887
1888 INSTALLUILEVEL WINAPI MsiSetInternalUI(INSTALLUILEVEL dwUILevel, HWND *phWnd)
1889 {
1890 INSTALLUILEVEL old = gUILevel;
1891 HWND oldwnd = gUIhwnd;
1892
1893 TRACE("%08x %p\n", dwUILevel, phWnd);
1894
1895 gUILevel = dwUILevel;
1896 if (phWnd)
1897 {
1898 gUIhwnd = *phWnd;
1899 *phWnd = oldwnd;
1900 }
1901 return old;
1902 }
1903
1904 INSTALLUI_HANDLERA WINAPI MsiSetExternalUIA(INSTALLUI_HANDLERA puiHandler,
1905 DWORD dwMessageFilter, LPVOID pvContext)
1906 {
1907 INSTALLUI_HANDLERA prev = gUIHandlerA;
1908
1909 TRACE("%p %08x %p\n", puiHandler, dwMessageFilter, pvContext);
1910
1911 gUIHandlerA = puiHandler;
1912 gUIHandlerW = NULL;
1913 gUIFilter = dwMessageFilter;
1914 gUIContext = pvContext;
1915
1916 return prev;
1917 }
1918
1919 INSTALLUI_HANDLERW WINAPI MsiSetExternalUIW(INSTALLUI_HANDLERW puiHandler,
1920 DWORD dwMessageFilter, LPVOID pvContext)
1921 {
1922 INSTALLUI_HANDLERW prev = gUIHandlerW;
1923
1924 TRACE("%p %08x %p\n", puiHandler, dwMessageFilter, pvContext);
1925
1926 gUIHandlerA = NULL;
1927 gUIHandlerW = puiHandler;
1928 gUIFilter = dwMessageFilter;
1929 gUIContext = pvContext;
1930
1931 return prev;
1932 }
1933
1934 /******************************************************************
1935 * MsiLoadStringW [MSI.@]
1936 *
1937 * Loads a string from MSI's string resources.
1938 *
1939 * PARAMS
1940 *
1941 * handle [I] only -1 is handled currently
1942 * id [I] id of the string to be loaded
1943 * lpBuffer [O] buffer for the string to be written to
1944 * nBufferMax [I] maximum size of the buffer in characters
1945 * lang [I] the preferred language for the string
1946 *
1947 * RETURNS
1948 *
1949 * If successful, this function returns the language id of the string loaded
1950 * If the function fails, the function returns zero.
1951 *
1952 * NOTES
1953 *
1954 * The type of the first parameter is unknown. LoadString's prototype
1955 * suggests that it might be a module handle. I have made it an MSI handle
1956 * for starters, as -1 is an invalid MSI handle, but not an invalid module
1957 * handle. Maybe strings can be stored in an MSI database somehow.
1958 */
1959 LANGID WINAPI MsiLoadStringW( MSIHANDLE handle, UINT id, LPWSTR lpBuffer,
1960 int nBufferMax, LANGID lang )
1961 {
1962 HRSRC hres;
1963 HGLOBAL hResData;
1964 LPWSTR p;
1965 DWORD i, len;
1966
1967 TRACE("%d %u %p %d %d\n", handle, id, lpBuffer, nBufferMax, lang);
1968
1969 if( handle != -1 )
1970 FIXME("don't know how to deal with handle = %08x\n", handle);
1971
1972 if( !lang )
1973 lang = GetUserDefaultLangID();
1974
1975 hres = FindResourceExW( msi_hInstance, (LPCWSTR) RT_STRING,
1976 (LPWSTR)1, lang );
1977 if( !hres )
1978 return 0;
1979 hResData = LoadResource( msi_hInstance, hres );
1980 if( !hResData )
1981 return 0;
1982 p = LockResource( hResData );
1983 if( !p )
1984 return 0;
1985
1986 for (i = 0; i < (id&0xf); i++)
1987 p += *p + 1;
1988 len = *p;
1989
1990 if( nBufferMax <= len )
1991 return 0;
1992
1993 memcpy( lpBuffer, p+1, len * sizeof(WCHAR));
1994 lpBuffer[ len ] = 0;
1995
1996 TRACE("found -> %s\n", debugstr_w(lpBuffer));
1997
1998 return lang;
1999 }
2000
2001 LANGID WINAPI MsiLoadStringA( MSIHANDLE handle, UINT id, LPSTR lpBuffer,
2002 int nBufferMax, LANGID lang )
2003 {
2004 LPWSTR bufW;
2005 LANGID r;
2006 INT len;
2007
2008 bufW = msi_alloc(nBufferMax*sizeof(WCHAR));
2009 r = MsiLoadStringW(handle, id, bufW, nBufferMax, lang);
2010 if( r )
2011 {
2012 len = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL, NULL );
2013 if( len <= nBufferMax )
2014 WideCharToMultiByte( CP_ACP, 0, bufW, -1,
2015 lpBuffer, nBufferMax, NULL, NULL );
2016 else
2017 r = 0;
2018 }
2019 msi_free(bufW);
2020 return r;
2021 }
2022
2023 INSTALLSTATE WINAPI MsiLocateComponentA(LPCSTR szComponent, LPSTR lpPathBuf,
2024 LPDWORD pcchBuf)
2025 {
2026 char szProduct[GUID_SIZE];
2027
2028 TRACE("%s %p %p\n", debugstr_a(szComponent), lpPathBuf, pcchBuf);
2029
2030 if (MsiGetProductCodeA( szComponent, szProduct ) != ERROR_SUCCESS)
2031 return INSTALLSTATE_UNKNOWN;
2032
2033 return MsiGetComponentPathA( szProduct, szComponent, lpPathBuf, pcchBuf );
2034 }
2035
2036 INSTALLSTATE WINAPI MsiLocateComponentW(LPCWSTR szComponent, LPWSTR lpPathBuf,
2037 LPDWORD pcchBuf)
2038 {
2039 WCHAR szProduct[GUID_SIZE];
2040
2041 TRACE("%s %p %p\n", debugstr_w(szComponent), lpPathBuf, pcchBuf);
2042
2043 if (MsiGetProductCodeW( szComponent, szProduct ) != ERROR_SUCCESS)
2044 return INSTALLSTATE_UNKNOWN;
2045
2046 return MsiGetComponentPathW( szProduct, szComponent, lpPathBuf, pcchBuf );
2047 }
2048
2049 UINT WINAPI MsiMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,
2050 WORD wLanguageId, DWORD f)
2051 {
2052 FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_a(lpText), debugstr_a(lpCaption),
2053 uType, wLanguageId, f);
2054 return MessageBoxExA(hWnd,lpText,lpCaption,uType,wLanguageId);
2055 }
2056
2057 UINT WINAPI MsiMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,
2058 WORD wLanguageId, DWORD f)
2059 {
2060 FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_w(lpText), debugstr_w(lpCaption),
2061 uType, wLanguageId, f);
2062 return MessageBoxExW(hWnd,lpText,lpCaption,uType,wLanguageId);
2063 }
2064
2065 UINT WINAPI MsiProvideAssemblyA( LPCSTR szAssemblyName, LPCSTR szAppContext,
2066 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPSTR lpPathBuf,
2067 LPDWORD pcchPathBuf )
2068 {
2069 FIXME("%s %s %08x %08x %p %p\n", debugstr_a(szAssemblyName),
2070 debugstr_a(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
2071 pcchPathBuf);
2072 return ERROR_CALL_NOT_IMPLEMENTED;
2073 }
2074
2075 UINT WINAPI MsiProvideAssemblyW( LPCWSTR szAssemblyName, LPCWSTR szAppContext,
2076 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPWSTR lpPathBuf,
2077 LPDWORD pcchPathBuf )
2078 {
2079 FIXME("%s %s %08x %08x %p %p\n", debugstr_w(szAssemblyName),
2080 debugstr_w(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
2081 pcchPathBuf);
2082 return ERROR_CALL_NOT_IMPLEMENTED;
2083 }
2084
2085 UINT WINAPI MsiProvideComponentFromDescriptorA( LPCSTR szDescriptor,
2086 LPSTR szPath, LPDWORD pcchPath, LPDWORD pcchArgs )
2087 {
2088 FIXME("%s %p %p %p\n", debugstr_a(szDescriptor), szPath, pcchPath, pcchArgs );
2089 return ERROR_CALL_NOT_IMPLEMENTED;
2090 }
2091
2092 UINT WINAPI MsiProvideComponentFromDescriptorW( LPCWSTR szDescriptor,
2093 LPWSTR szPath, LPDWORD pcchPath, LPDWORD pcchArgs )
2094 {
2095 FIXME("%s %p %p %p\n", debugstr_w(szDescriptor), szPath, pcchPath, pcchArgs );
2096 return ERROR_CALL_NOT_IMPLEMENTED;
2097 }
2098
2099 HRESULT WINAPI MsiGetFileSignatureInformationA( LPCSTR szSignedObjectPath,
2100 DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, LPBYTE pbHashData,
2101 LPDWORD pcbHashData)
2102 {
2103 FIXME("%s %08x %p %p %p\n", debugstr_a(szSignedObjectPath), dwFlags,
2104 ppcCertContext, pbHashData, pcbHashData);
2105 return ERROR_CALL_NOT_IMPLEMENTED;
2106 }
2107
2108 HRESULT WINAPI MsiGetFileSignatureInformationW( LPCWSTR szSignedObjectPath,
2109 DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, LPBYTE pbHashData,
2110 LPDWORD pcbHashData)
2111 {
2112 FIXME("%s %08x %p %p %p\n", debugstr_w(szSignedObjectPath), dwFlags,
2113 ppcCertContext, pbHashData, pcbHashData);
2114 return ERROR_CALL_NOT_IMPLEMENTED;
2115 }
2116
2117 /******************************************************************
2118 * MsiGetProductPropertyA [MSI.@]
2119 */
2120 UINT WINAPI MsiGetProductPropertyA(MSIHANDLE hProduct, LPCSTR szProperty,
2121 LPSTR szValue, LPDWORD pccbValue)
2122 {
2123 LPWSTR prop = NULL, val = NULL;
2124 DWORD len;
2125 UINT r;
2126
2127 TRACE("(%d, %s, %p, %p)\n", hProduct, debugstr_a(szProperty),
2128 szValue, pccbValue);
2129
2130 if (szValue && !pccbValue)
2131 return ERROR_INVALID_PARAMETER;
2132
2133 if (szProperty) prop = strdupAtoW(szProperty);
2134
2135 len = 0;
2136 r = MsiGetProductPropertyW(hProduct, prop, NULL, &len);
2137 if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
2138 goto done;
2139
2140 if (r == ERROR_SUCCESS)
2141 {
2142 if (szValue) *szValue = '\0';
2143 if (pccbValue) *pccbValue = 0;
2144 goto done;
2145 }
2146
2147 val = msi_alloc(++len * sizeof(WCHAR));
2148 if (!val)
2149 {
2150 r = ERROR_OUTOFMEMORY;
2151 goto done;
2152 }
2153
2154 r = MsiGetProductPropertyW(hProduct, prop, val, &len);
2155 if (r != ERROR_SUCCESS)
2156 goto done;
2157
2158 len = WideCharToMultiByte(CP_ACP, 0, val, -1, NULL, 0, NULL, NULL);
2159
2160 if (szValue)
2161 WideCharToMultiByte(CP_ACP, 0, val, -1, szValue,
2162 *pccbValue, NULL, NULL);
2163
2164 if (pccbValue)
2165 {
2166 if (len > *pccbValue)
2167 r = ERROR_MORE_DATA;
2168
2169 *pccbValue = len - 1;
2170 }
2171
2172 done:
2173 msi_free(prop);
2174 msi_free(val);
2175
2176 return r;
2177 }
2178
2179 /******************************************************************
2180 * MsiGetProductPropertyW [MSI.@]
2181 */
2182 UINT WINAPI MsiGetProductPropertyW(MSIHANDLE hProduct, LPCWSTR szProperty,
2183 LPWSTR szValue, LPDWORD pccbValue)
2184 {
2185 MSIPACKAGE *package;
2186 MSIQUERY *view = NULL;
2187 MSIRECORD *rec = NULL;
2188 LPCWSTR val;
2189 UINT r;
2190
2191 static const WCHAR query[] = {
2192 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2193 '`','P','r','o','p','e','r','t','y','`',' ','W','H','E','R','E',' ',
2194 '`','P','r','o','p','e','r','t','y','`','=','\'','%','s','\'',0};
2195
2196 TRACE("(%d, %s, %p, %p)\n", hProduct, debugstr_w(szProperty),
2197 szValue, pccbValue);
2198
2199 if (!szProperty)
2200 return ERROR_INVALID_PARAMETER;
2201
2202 if (szValue && !pccbValue)
2203 return ERROR_INVALID_PARAMETER;
2204
2205 package = msihandle2msiinfo(hProduct, MSIHANDLETYPE_PACKAGE);
2206 if (!package)
2207 return ERROR_INVALID_HANDLE;
2208
2209 r = MSI_OpenQuery(package->db, &view, query, szProperty);
2210 if (r != ERROR_SUCCESS)
2211 goto done;
2212
2213 r = MSI_ViewExecute(view, 0);
2214 if (r != ERROR_SUCCESS)
2215 goto done;
2216
2217 r = MSI_ViewFetch(view, &rec);
2218 if (r != ERROR_SUCCESS)
2219 goto done;
2220
2221 val = MSI_RecordGetString(rec, 2);
2222 if (!val)
2223 goto done;
2224
2225 if (lstrlenW(val) >= *pccbValue)
2226 {
2227 lstrcpynW(szValue, val, *pccbValue);
2228 *pccbValue = lstrlenW(val);
2229 r = ERROR_MORE_DATA;
2230 }
2231 else
2232 {
2233 lstrcpyW(szValue, val);
2234 *pccbValue = lstrlenW(val);
2235 r = ERROR_SUCCESS;
2236 }
2237
2238 done:
2239 if (view)
2240 {
2241 MSI_ViewClose(view);
2242 msiobj_release(&view->hdr);
2243 if (rec) msiobj_release(&rec->hdr);
2244 }
2245
2246 if (!rec)
2247 {
2248 if (szValue) *szValue = '\0';
2249 if (pccbValue) *pccbValue = 0;
2250 r = ERROR_SUCCESS;
2251 }
2252
2253 return r;
2254 }
2255
2256 UINT WINAPI MsiVerifyPackageA( LPCSTR szPackage )
2257 {
2258 UINT r;
2259 LPWSTR szPack = NULL;
2260
2261 TRACE("%s\n", debugstr_a(szPackage) );
2262
2263 if( szPackage )
2264 {
2265 szPack = strdupAtoW( szPackage );
2266 if( !szPack )
2267 return ERROR_OUTOFMEMORY;
2268 }
2269
2270 r = MsiVerifyPackageW( szPack );
2271
2272 msi_free( szPack );
2273
2274 return r;
2275 }
2276
2277 UINT WINAPI MsiVerifyPackageW( LPCWSTR szPackage )
2278 {
2279 MSIHANDLE handle;
2280 UINT r;
2281
2282 TRACE("%s\n", debugstr_w(szPackage) );
2283
2284 r = MsiOpenDatabaseW( szPackage, MSIDBOPEN_READONLY, &handle );
2285 MsiCloseHandle( handle );
2286
2287 return r;
2288 }
2289
2290 static INSTALLSTATE MSI_GetComponentPath(LPCWSTR szProduct, LPCWSTR szComponent,
2291 awstring* lpPathBuf, LPDWORD pcchBuf)
2292 {
2293 WCHAR squished_pc[GUID_SIZE];
2294 WCHAR squished_comp[GUID_SIZE];
2295 HKEY hkey;
2296 LPWSTR path = NULL;
2297 INSTALLSTATE state;
2298 DWORD version;
2299
2300 static const WCHAR wininstaller[] = {
2301 'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
2302
2303 TRACE("%s %s %p %p\n", debugstr_w(szProduct),
2304 debugstr_w(szComponent), lpPathBuf->str.w, pcchBuf);
2305
2306 if (!szProduct || !szComponent)
2307 return INSTALLSTATE_INVALIDARG;
2308
2309 if (lpPathBuf->str.w && !pcchBuf)
2310 return INSTALLSTATE_INVALIDARG;
2311
2312 if (!squash_guid(szProduct, squished_pc) ||
2313 !squash_guid(szComponent, squished_comp))
2314 return INSTALLSTATE_INVALIDARG;
2315
2316 state = INSTALLSTATE_UNKNOWN;
2317
2318 if (MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkey, FALSE) == ERROR_SUCCESS ||
2319 MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkey, FALSE) == ERROR_SUCCESS)
2320 {
2321 path = msi_reg_get_val_str(hkey, squished_pc);
2322 RegCloseKey(hkey);
2323
2324 state = INSTALLSTATE_ABSENT;
2325
2326 if ((MSIREG_OpenInstallProps(szProduct, MSIINSTALLCONTEXT_MACHINE, NULL,
2327 &hkey, FALSE) == ERROR_SUCCESS ||
2328 MSIREG_OpenUserDataProductKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
2329 NULL, &hkey, FALSE) == ERROR_SUCCESS) &&
2330 msi_reg_get_val_dword(hkey, wininstaller, &version) &&
2331 GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
2332 {
2333 RegCloseKey(hkey);
2334 state = INSTALLSTATE_LOCAL;
2335 }
2336 }
2337
2338 if (state != INSTALLSTATE_LOCAL &&
2339 (MSIREG_OpenProductKey(szProduct, NULL,
2340 MSIINSTALLCONTEXT_USERUNMANAGED,
2341 &hkey, FALSE) == ERROR_SUCCESS ||
2342 MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
2343 &hkey, FALSE) == ERROR_SUCCESS))
2344 {
2345 RegCloseKey(hkey);
2346
2347 if (MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkey, FALSE) == ERROR_SUCCESS ||
2348 MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkey, FALSE) == ERROR_SUCCESS)
2349 {
2350 msi_free(path);
2351 path = msi_reg_get_val_str(hkey, squished_pc);
2352 RegCloseKey(hkey);
2353
2354 state = INSTALLSTATE_ABSENT;
2355
2356 if (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
2357 state = INSTALLSTATE_LOCAL;
2358 }
2359 }
2360
2361 if (!path)
2362 return INSTALLSTATE_UNKNOWN;
2363
2364 if (state == INSTALLSTATE_LOCAL && !*path)
2365 state = INSTALLSTATE_NOTUSED;
2366
2367 msi_strcpy_to_awstring(path, lpPathBuf, pcchBuf);
2368 msi_free(path);
2369 return state;
2370 }
2371
2372 /******************************************************************
2373 * MsiGetComponentPathW [MSI.@]
2374 */
2375 INSTALLSTATE WINAPI MsiGetComponentPathW(LPCWSTR szProduct, LPCWSTR szComponent,
2376 LPWSTR lpPathBuf, LPDWORD pcchBuf)
2377 {
2378 awstring path;
2379
2380 path.unicode = TRUE;
2381 path.str.w = lpPathBuf;
2382
2383 return MSI_GetComponentPath( szProduct, szComponent, &path, pcchBuf );
2384 }
2385
2386 /******************************************************************
2387 * MsiGetComponentPathA [MSI.@]
2388 */
2389 INSTALLSTATE WINAPI MsiGetComponentPathA(LPCSTR szProduct, LPCSTR szComponent,
2390 LPSTR lpPathBuf, LPDWORD pcchBuf)
2391 {
2392 LPWSTR szwProduct, szwComponent = NULL;
2393 INSTALLSTATE r = INSTALLSTATE_UNKNOWN;
2394 awstring path;
2395
2396 szwProduct = strdupAtoW( szProduct );
2397 if( szProduct && !szwProduct)
2398 goto end;
2399
2400 szwComponent = strdupAtoW( szComponent );
2401 if( szComponent && !szwComponent )
2402 goto end;
2403
2404 path.unicode = FALSE;
2405 path.str.a = lpPathBuf;
2406
2407 r = MSI_GetComponentPath( szwProduct, szwComponent, &path, pcchBuf );
2408
2409 end:
2410 msi_free( szwProduct );
2411 msi_free( szwComponent );
2412
2413 return r;
2414 }
2415
2416 /******************************************************************
2417 * MsiQueryFeatureStateA [MSI.@]
2418 */
2419 INSTALLSTATE WINAPI MsiQueryFeatureStateA(LPCSTR szProduct, LPCSTR szFeature)
2420 {
2421 LPWSTR szwProduct = NULL, szwFeature= NULL;
2422 INSTALLSTATE rc = INSTALLSTATE_UNKNOWN;
2423
2424 szwProduct = strdupAtoW( szProduct );
2425 if ( szProduct && !szwProduct )
2426 goto end;
2427
2428 szwFeature = strdupAtoW( szFeature );
2429 if ( szFeature && !szwFeature )
2430 goto end;
2431
2432 rc = MsiQueryFeatureStateW(szwProduct, szwFeature);
2433
2434 end:
2435 msi_free( szwProduct);
2436 msi_free( szwFeature);
2437
2438 return rc;
2439 }
2440
2441 /******************************************************************
2442 * MsiQueryFeatureStateW [MSI.@]
2443 *
2444 * Checks the state of a feature
2445 *
2446 * PARAMS
2447 * szProduct [I] Product's GUID string
2448 * szFeature [I] Feature's GUID string
2449 *
2450 * RETURNS
2451 * INSTALLSTATE_LOCAL Feature is installed and usable
2452 * INSTALLSTATE_ABSENT Feature is absent
2453 * INSTALLSTATE_ADVERTISED Feature should be installed on demand
2454 * INSTALLSTATE_UNKNOWN An error occurred
2455 * INSTALLSTATE_INVALIDARG One of the GUIDs was invalid
2456 *
2457 */
2458 INSTALLSTATE WINAPI MsiQueryFeatureStateW(LPCWSTR szProduct, LPCWSTR szFeature)
2459 {
2460 WCHAR squishProduct[33], comp[GUID_SIZE];
2461 GUID guid;
2462 LPWSTR components, p, parent_feature, path;
2463 UINT rc;
2464 HKEY hkey;
2465 INSTALLSTATE r;
2466 BOOL missing = FALSE;
2467 BOOL machine = FALSE;
2468 BOOL source = FALSE;
2469
2470 TRACE("%s %s\n", debugstr_w(szProduct), debugstr_w(szFeature));
2471
2472 if (!szProduct || !szFeature)
2473 return INSTALLSTATE_INVALIDARG;
2474
2475 if (!squash_guid( szProduct, squishProduct ))
2476 return INSTALLSTATE_INVALIDARG;
2477
2478 if (MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_USERMANAGED,
2479 &hkey, FALSE) != ERROR_SUCCESS &&
2480 MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
2481 &hkey, FALSE) != ERROR_SUCCESS)
2482 {
2483 rc = MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_MACHINE,
2484 &hkey, FALSE);
2485 if (rc != ERROR_SUCCESS)
2486 return INSTALLSTATE_UNKNOWN;
2487
2488 machine = TRUE;
2489 }
2490
2491 parent_feature = msi_reg_get_val_str( hkey, szFeature );
2492 RegCloseKey(hkey);
2493
2494 if (!parent_feature)
2495 return INSTALLSTATE_UNKNOWN;
2496
2497 r = (parent_feature[0] == 6) ? INSTALLSTATE_ABSENT : INSTALLSTATE_LOCAL;
2498 msi_free(parent_feature);
2499 if (r == INSTALLSTATE_ABSENT)
2500 return r;
2501
2502 if (machine)
2503 rc = MSIREG_OpenUserDataFeaturesKey(szProduct,
2504 MSIINSTALLCONTEXT_MACHINE,
2505 &hkey, FALSE);
2506 else
2507 rc = MSIREG_OpenUserDataFeaturesKey(szProduct,
2508 MSIINSTALLCONTEXT_USERUNMANAGED,
2509 &hkey, FALSE);
2510
2511 if (rc != ERROR_SUCCESS)
2512 return INSTALLSTATE_ADVERTISED;
2513
2514 components = msi_reg_get_val_str( hkey, szFeature );
2515 RegCloseKey(hkey);
2516
2517 TRACE("rc = %d buffer = %s\n", rc, debugstr_w(components));
2518
2519 if (!components)
2520 return INSTALLSTATE_ADVERTISED;
2521
2522 for( p = components; *p && *p != 2 ; p += 20)
2523 {
2524 if (!decode_base85_guid( p, &guid ))
2525 {
2526 if (p != components)
2527 break;
2528
2529 msi_free(components);
2530 return INSTALLSTATE_BADCONFIG;
2531 }
2532
2533 StringFromGUID2(&guid, comp, GUID_SIZE);
2534
2535 if (machine)
2536 rc = MSIREG_OpenUserDataComponentKey(comp, szLocalSid, &hkey, FALSE);
2537 else
2538 rc = MSIREG_OpenUserDataComponentKey(comp, NULL, &hkey, FALSE);
2539
2540 if (rc != ERROR_SUCCESS)
2541 {
2542 msi_free(components);
2543 return INSTALLSTATE_ADVERTISED;
2544 }
2545
2546 path = msi_reg_get_val_str(hkey, squishProduct);
2547 if (!path)
2548 missing = TRUE;
2549 else if (lstrlenW(path) > 2 &&
2550 path[0] >= '0' && path[0] <= '9' &&
2551 path[1] >= '0' && path[1] <= '9')
2552 {
2553 source = TRUE;
2554 }
2555
2556 msi_free(path);
2557 }
2558
2559 TRACE("%s %s -> %d\n", debugstr_w(szProduct), debugstr_w(szFeature), r);
2560 msi_free(components);
2561
2562 if (missing)
2563 return INSTALLSTATE_ADVERTISED;
2564
2565 if (source)
2566 return INSTALLSTATE_SOURCE;
2567
2568 return INSTALLSTATE_LOCAL;
2569 }
2570
2571 /******************************************************************
2572 * MsiGetFileVersionA [MSI.@]
2573 */
2574 UINT WINAPI MsiGetFileVersionA(LPCSTR szFilePath, LPSTR lpVersionBuf,
2575 LPDWORD pcchVersionBuf, LPSTR lpLangBuf, LPDWORD pcchLangBuf)
2576 {
2577 LPWSTR szwFilePath = NULL, lpwVersionBuff = NULL, lpwLangBuff = NULL;
2578 UINT ret = ERROR_OUTOFMEMORY;
2579
2580 if ((lpVersionBuf && !pcchVersionBuf) ||
2581 (lpLangBuf && !pcchLangBuf))
2582 return ERROR_INVALID_PARAMETER;
2583
2584 if( szFilePath )
2585 {
2586 szwFilePath = strdupAtoW( szFilePath );
2587 if( !szwFilePath )
2588 goto end;
2589 }
2590
2591 if( lpVersionBuf && pcchVersionBuf && *pcchVersionBuf )
2592 {
2593 lpwVersionBuff = msi_alloc(*pcchVersionBuf*sizeof(WCHAR));
2594 if( !lpwVersionBuff )
2595 goto end;
2596 }
2597
2598 if( lpLangBuf && pcchLangBuf && *pcchLangBuf )
2599 {
2600 lpwLangBuff = msi_alloc(*pcchLangBuf*sizeof(WCHAR));
2601 if( !lpwLangBuff )
2602 goto end;
2603 }
2604
2605 ret = MsiGetFileVersionW(szwFilePath, lpwVersionBuff, pcchVersionBuf,
2606 lpwLangBuff, pcchLangBuf);
2607
2608 if( (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && lpwVersionBuff )
2609 WideCharToMultiByte(CP_ACP, 0, lpwVersionBuff, -1,
2610 lpVersionBuf, *pcchVersionBuf + 1, NULL, NULL);
2611 if( (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && lpwLangBuff )
2612 WideCharToMultiByte(CP_ACP, 0, lpwLangBuff, -1,
2613 lpLangBuf, *pcchLangBuf + 1, NULL, NULL);
2614
2615 end:
2616 msi_free(szwFilePath);
2617 msi_free(lpwVersionBuff);
2618 msi_free(lpwLangBuff);
2619
2620 return ret;
2621 }
2622
2623 /******************************************************************
2624 * MsiGetFileVersionW [MSI.@]
2625 */
2626 UINT WINAPI MsiGetFileVersionW(LPCWSTR szFilePath, LPWSTR lpVersionBuf,
2627 LPDWORD pcchVersionBuf, LPWSTR lpLangBuf, LPDWORD pcchLangBuf)
2628 {
2629 static const WCHAR szVersionResource[] = {'\\',0};
2630 static const WCHAR szVersionFormat[] = {
2631 '%','d','.','%','d','.','%','d','.','%','d',0};
2632 static const WCHAR szLangResource[] = {
2633 '\\','V','a','r','F','i','l','e','I','n','f','o','\\',
2634 'T','r','a','n','s','l','a','t','i','o','n',0};
2635 static const WCHAR szLangFormat[] = {'%','d',0};
2636 UINT ret = 0;
2637 DWORD dwVerLen, gle;
2638 LPVOID lpVer = NULL;
2639 VS_FIXEDFILEINFO *ffi;
2640 USHORT *lang;
2641 UINT puLen;
2642 WCHAR tmp[32];
2643
2644 TRACE("%s %p %d %p %d\n", debugstr_w(szFilePath),
2645 lpVersionBuf, pcchVersionBuf?*pcchVersionBuf:0,
2646 lpLangBuf, pcchLangBuf?*pcchLangBuf:0);
2647
2648 if ((lpVersionBuf && !pcchVersionBuf) ||
2649 (lpLangBuf && !pcchLangBuf))
2650 return ERROR_INVALID_PARAMETER;
2651
2652 dwVerLen = GetFileVersionInfoSizeW(szFilePath, NULL);
2653 if( !dwVerLen )
2654 {
2655 gle = GetLastError();
2656 if (gle == ERROR_BAD_PATHNAME)
2657 return ERROR_FILE_NOT_FOUND;
2658 else if (gle == ERROR_RESOURCE_DATA_NOT_FOUND)
2659 return ERROR_FILE_INVALID;
2660
2661 return gle;
2662 }
2663
2664 lpVer = msi_alloc(dwVerLen);
2665 if( !lpVer )
2666 {
2667 ret = ERROR_OUTOFMEMORY;
2668 goto end;
2669 }
2670
2671 if( !GetFileVersionInfoW(szFilePath, 0, dwVerLen, lpVer) )
2672 {
2673 ret = GetLastError();
2674 goto end;
2675 }
2676
2677 if (pcchVersionBuf)
2678 {
2679 if( VerQueryValueW(lpVer, szVersionResource, (LPVOID*)&ffi, &puLen) &&
2680 (puLen > 0) )
2681 {
2682 wsprintfW(tmp, szVersionFormat,
2683 HIWORD(ffi->dwFileVersionMS), LOWORD(ffi->dwFileVersionMS),
2684 HIWORD(ffi->dwFileVersionLS), LOWORD(ffi->dwFileVersionLS));
2685 if (lpVersionBuf) lstrcpynW(lpVersionBuf, tmp, *pcchVersionBuf);
2686
2687 if (strlenW(tmp) >= *pcchVersionBuf)
2688 ret = ERROR_MORE_DATA;
2689
2690 *pcchVersionBuf = lstrlenW(tmp);
2691 }
2692 else
2693 {
2694 if (lpVersionBuf) *lpVersionBuf = 0;
2695 *pcchVersionBuf = 0;
2696 }
2697 }
2698
2699 if (pcchLangBuf)
2700 {
2701 if (VerQueryValueW(lpVer, szLangResource, (LPVOID*)&lang, &puLen) &&
2702 (puLen > 0))
2703 {
2704 wsprintfW(tmp, szLangFormat, *lang);
2705 if (lpLangBuf) lstrcpynW(lpLangBuf, tmp, *pcchLangBuf);
2706
2707 if (strlenW(tmp) >= *pcchLangBuf)
2708 ret = ERROR_MORE_DATA;
2709
2710 *pcchLangBuf = lstrlenW(tmp);
2711 }
2712 else
2713 {
2714 if (lpLangBuf) *lpLangBuf = 0;
2715 *pcchLangBuf = 0;
2716 }
2717 }
2718
2719 end:
2720 msi_free(lpVer);
2721 return ret;
2722 }
2723
2724 /***********************************************************************
2725 * MsiGetFeatureUsageW [MSI.@]
2726 */
2727 UINT WINAPI MsiGetFeatureUsageW( LPCWSTR szProduct, LPCWSTR szFeature,
2728 LPDWORD pdwUseCount, LPWORD pwDateUsed )
2729 {
2730 FIXME("%s %s %p %p\n",debugstr_w(szProduct), debugstr_w(szFeature),
2731 pdwUseCount, pwDateUsed);
2732 return ERROR_CALL_NOT_IMPLEMENTED;
2733 }
2734
2735 /***********************************************************************
2736 * MsiGetFeatureUsageA [MSI.@]
2737 */
2738 UINT WINAPI MsiGetFeatureUsageA( LPCSTR szProduct, LPCSTR szFeature,
2739 LPDWORD pdwUseCount, LPWORD pwDateUsed )
2740 {
2741 LPWSTR prod = NULL, feat = NULL;
2742 UINT ret = ERROR_OUTOFMEMORY;
2743
2744 TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szFeature),
2745 pdwUseCount, pwDateUsed);
2746
2747 prod = strdupAtoW( szProduct );
2748 if (szProduct && !prod)
2749 goto end;
2750
2751 feat = strdupAtoW( szFeature );
2752 if (szFeature && !feat)
2753 goto end;
2754
2755 ret = MsiGetFeatureUsageW( prod, feat, pdwUseCount, pwDateUsed );
2756
2757 end:
2758 msi_free( prod );
2759 msi_free( feat );
2760
2761 return ret;
2762 }
2763
2764 /***********************************************************************
2765 * MsiUseFeatureExW [MSI.@]
2766 */
2767 INSTALLSTATE WINAPI MsiUseFeatureExW( LPCWSTR szProduct, LPCWSTR szFeature,
2768 DWORD dwInstallMode, DWORD dwReserved )
2769 {
2770 INSTALLSTATE state;
2771
2772 TRACE("%s %s %i %i\n", debugstr_w(szProduct), debugstr_w(szFeature),
2773 dwInstallMode, dwReserved);
2774
2775 state = MsiQueryFeatureStateW( szProduct, szFeature );
2776
2777 if (dwReserved)
2778 return INSTALLSTATE_INVALIDARG;
2779
2780 if (state == INSTALLSTATE_LOCAL && dwInstallMode != INSTALLMODE_NODETECTION)
2781 {
2782 FIXME("mark product %s feature %s as used\n",
2783 debugstr_w(szProduct), debugstr_w(szFeature) );
2784 }
2785
2786 return state;
2787 }
2788
2789 /***********************************************************************
2790 * MsiUseFeatureExA [MSI.@]
2791 */
2792 INSTALLSTATE WINAPI MsiUseFeatureExA( LPCSTR szProduct, LPCSTR szFeature,
2793 DWORD dwInstallMode, DWORD dwReserved )
2794 {
2795 INSTALLSTATE ret = INSTALLSTATE_UNKNOWN;
2796 LPWSTR prod = NULL, feat = NULL;
2797
2798 TRACE("%s %s %i %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
2799 dwInstallMode, dwReserved);
2800
2801 prod = strdupAtoW( szProduct );
2802 if (szProduct && !prod)
2803 goto end;
2804
2805 feat = strdupAtoW( szFeature );
2806 if (szFeature && !feat)
2807 goto end;
2808
2809 ret = MsiUseFeatureExW( prod, feat, dwInstallMode, dwReserved );
2810
2811 end:
2812 msi_free( prod );
2813 msi_free( feat );
2814
2815 return ret;
2816 }
2817
2818 /***********************************************************************
2819 * MsiUseFeatureW [MSI.@]
2820 */
2821 INSTALLSTATE WINAPI MsiUseFeatureW( LPCWSTR szProduct, LPCWSTR szFeature )
2822 {
2823 return MsiUseFeatureExW(szProduct, szFeature, 0, 0);
2824 }
2825
2826 /***********************************************************************
2827 * MsiUseFeatureA [MSI.@]
2828 */
2829 INSTALLSTATE WINAPI MsiUseFeatureA( LPCSTR szProduct, LPCSTR szFeature )
2830 {
2831 return MsiUseFeatureExA(szProduct, szFeature, 0, 0);
2832 }
2833
2834 /***********************************************************************
2835 * MSI_ProvideQualifiedComponentEx [internal]
2836 */
2837 static UINT MSI_ProvideQualifiedComponentEx(LPCWSTR szComponent,
2838 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
2839 DWORD Unused1, DWORD Unused2, awstring *lpPathBuf,
2840 LPDWORD pcchPathBuf)
2841 {
2842 WCHAR product[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1],
2843 feature[MAX_FEATURE_CHARS+1];
2844 LPWSTR info;
2845 HKEY hkey;
2846 DWORD sz;
2847 UINT rc;
2848
2849 TRACE("%s %s %i %s %i %i %p %p\n", debugstr_w(szComponent),
2850 debugstr_w(szQualifier), dwInstallMode, debugstr_w(szProduct),
2851 Unused1, Unused2, lpPathBuf, pcchPathBuf);
2852
2853 rc = MSIREG_OpenUserComponentsKey(szComponent, &hkey, FALSE);
2854 if (rc != ERROR_SUCCESS)
2855 return ERROR_INDEX_ABSENT;
2856
2857 info = msi_reg_get_val_str( hkey, szQualifier );
2858 RegCloseKey(hkey);
2859
2860 if (!info)
2861 return ERROR_INDEX_ABSENT;
2862
2863 MsiDecomposeDescriptorW(info, product, feature, component, &sz);
2864
2865 if (!szProduct)
2866 rc = MSI_GetComponentPath(product, component, lpPathBuf, pcchPathBuf);
2867 else
2868 rc = MSI_GetComponentPath(szProduct, component, lpPathBuf, pcchPathBuf);
2869
2870 msi_free( info );
2871
2872 if (rc != INSTALLSTATE_LOCAL)
2873 return ERROR_FILE_NOT_FOUND;
2874
2875 return ERROR_SUCCESS;
2876 }
2877
2878 /***********************************************************************
2879 * MsiProvideQualifiedComponentExW [MSI.@]
2880 */
2881 UINT WINAPI MsiProvideQualifiedComponentExW(LPCWSTR szComponent,
2882 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
2883 DWORD Unused1, DWORD Unused2, LPWSTR lpPathBuf,
2884 LPDWORD pcchPathBuf)
2885 {
2886 awstring path;
2887
2888 path.unicode = TRUE;
2889 path.str.w = lpPathBuf;
2890
2891 return MSI_ProvideQualifiedComponentEx(szComponent, szQualifier,
2892 dwInstallMode, szProduct, Unused1, Unused2, &path, pcchPathBuf);
2893 }
2894
2895 /***********************************************************************
2896 * MsiProvideQualifiedComponentExA [MSI.@]
2897 */
2898 UINT WINAPI MsiProvideQualifiedComponentExA(LPCSTR szComponent,
2899 LPCSTR szQualifier, DWORD dwInstallMode, LPCSTR szProduct,
2900 DWORD Unused1, DWORD Unused2, LPSTR lpPathBuf,
2901 LPDWORD pcchPathBuf)
2902 {
2903 LPWSTR szwComponent, szwQualifier = NULL, szwProduct = NULL;
2904 UINT r = ERROR_OUTOFMEMORY;
2905 awstring path;
2906
2907 TRACE("%s %s %u %s %u %u %p %p\n", debugstr_a(szComponent),
2908 debugstr_a(szQualifier), dwInstallMode, debugstr_a(szProduct),
2909 Unused1, Unused2, lpPathBuf, pcchPathBuf);
2910
2911 szwComponent = strdupAtoW( szComponent );
2912 if (szComponent && !szwComponent)
2913 goto end;
2914
2915 szwQualifier = strdupAtoW( szQualifier );
2916 if (szQualifier && !szwQualifier)
2917 goto end;
2918
2919 szwProduct = strdupAtoW( szProduct );
2920 if (szProduct && !szwProduct)
2921 goto end;
2922
2923 path.unicode = FALSE;
2924 path.str.a = lpPathBuf;
2925
2926 r = MSI_ProvideQualifiedComponentEx(szwComponent, szwQualifier,
2927 dwInstallMode, szwProduct, Unused1,
2928 Unused2, &path, pcchPathBuf);
2929 end:
2930 msi_free(szwProduct);
2931 msi_free(szwComponent);
2932 msi_free(szwQualifier);
2933
2934 return r;
2935 }
2936
2937 /***********************************************************************
2938 * MsiProvideQualifiedComponentW [MSI.@]
2939 */
2940 UINT WINAPI MsiProvideQualifiedComponentW( LPCWSTR szComponent,
2941 LPCWSTR szQualifier, DWORD dwInstallMode, LPWSTR lpPathBuf,
2942 LPDWORD pcchPathBuf)
2943 {
2944 return MsiProvideQualifiedComponentExW(szComponent, szQualifier,
2945 dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
2946 }
2947
2948 /***********************************************************************
2949 * MsiProvideQualifiedComponentA [MSI.@]
2950 */
2951 UINT WINAPI MsiProvideQualifiedComponentA( LPCSTR szComponent,
2952 LPCSTR szQualifier, DWORD dwInstallMode, LPSTR lpPathBuf,
2953 LPDWORD pcchPathBuf)
2954 {
2955 return MsiProvideQualifiedComponentExA(szComponent, szQualifier,
2956 dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
2957 }
2958
2959 /***********************************************************************
2960 * MSI_GetUserInfo [internal]
2961 */
2962 static USERINFOSTATE MSI_GetUserInfo(LPCWSTR szProduct,
2963 awstring *lpUserNameBuf, LPDWORD pcchUserNameBuf,
2964 awstring *lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
2965 awstring *lpSerialBuf, LPDWORD pcchSerialBuf)
2966 {
2967 WCHAR squished_pc[SQUISH_GUID_SIZE];
2968 LPWSTR user, org, serial;
2969 USERINFOSTATE state;
2970 HKEY hkey, props;
2971 LPCWSTR orgptr;
2972 UINT r;
2973
2974 TRACE("%s %p %p %p %p %p %p\n", debugstr_w(szProduct), lpUserNameBuf,
2975 pcchUserNameBuf, lpOrgNameBuf, pcchOrgNameBuf, lpSerialBuf,
2976 pcchSerialBuf);
2977
2978 if (!szProduct || !squash_guid(szProduct, squished_pc))
2979 return USERINFOSTATE_INVALIDARG;
2980
2981 if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
2982 &hkey, FALSE) != ERROR_SUCCESS &&
2983 MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2984 &hkey, FALSE) != ERROR_SUCCESS &&
2985 MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
2986 &hkey, FALSE) != ERROR_SUCCESS)
2987 {
2988 return USERINFOSTATE_UNKNOWN;
2989 }
2990
2991 if (MSIREG_OpenInstallProps(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
2992 NULL, &props, FALSE) != ERROR_SUCCESS &&
2993 MSIREG_OpenInstallProps(szProduct, MSIINSTALLCONTEXT_MACHINE,
2994 NULL, &props, FALSE) != ERROR_SUCCESS)
2995 {
2996 RegCloseKey(hkey);
2997 return USERINFOSTATE_ABSENT;
2998 }
2999
3000 user = msi_reg_get_val_str(props, INSTALLPROPERTY_REGOWNERW);
3001 org = msi_reg_get_val_str(props, INSTALLPROPERTY_REGCOMPANYW);
3002 serial = msi_reg_get_val_str(props, INSTALLPROPERTY_PRODUCTIDW);
3003 state = USERINFOSTATE_ABSENT;
3004
3005 RegCloseKey(hkey);
3006 RegCloseKey(props);
3007
3008 if (user && serial)
3009 state = USERINFOSTATE_PRESENT;
3010
3011 if (pcchUserNameBuf)
3012 {
3013 if (lpUserNameBuf && !user)
3014 {
3015 (*pcchUserNameBuf)--;
3016 goto done;
3017 }
3018
3019 r = msi_strcpy_to_awstring(user, lpUserNameBuf, pcchUserNameBuf);
3020 if (r == ERROR_MORE_DATA)
3021 {
3022 state = USERINFOSTATE_MOREDATA;
3023 goto done;
3024 }
3025 }
3026
3027 if (pcchOrgNameBuf)
3028 {
3029 orgptr = org;
3030 if (!orgptr) orgptr = szEmpty;
3031
3032 r = msi_strcpy_to_awstring(orgptr, lpOrgNameBuf, pcchOrgNameBuf);
3033 if (r == ERROR_MORE_DATA)
3034 {
3035 state = USERINFOSTATE_MOREDATA;
3036 goto done;
3037 }
3038 }
3039
3040 if (pcchSerialBuf)
3041 {
3042 if (!serial)
3043 {
3044 (*pcchSerialBuf)--;
3045 goto done;
3046 }
3047
3048 r = msi_strcpy_to_awstring(serial, lpSerialBuf, pcchSerialBuf);
3049 if (r == ERROR_MORE_DATA)
3050 state = USERINFOSTATE_MOREDATA;
3051 }
3052
3053 done:
3054 msi_free(user);
3055 msi_free(org);
3056 msi_free(serial);
3057
3058 return state;
3059 }
3060
3061 /***********************************************************************
3062 * MsiGetUserInfoW [MSI.@]
3063 */
3064 USERINFOSTATE WINAPI MsiGetUserInfoW(LPCWSTR szProduct,
3065 LPWSTR lpUserNameBuf, LPDWORD pcchUserNameBuf,
3066 LPWSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
3067 LPWSTR lpSerialBuf, LPDWORD pcchSerialBuf)
3068 {
3069 awstring user, org, serial;
3070
3071 if ((lpUserNameBuf && !pcchUserNameBuf) ||
3072 (lpOrgNameBuf && !pcchOrgNameBuf) ||
3073 (lpSerialBuf && !pcchSerialBuf))
3074 return USERINFOSTATE_INVALIDARG;
3075
3076 user.unicode = TRUE;
3077 user.str.w = lpUserNameBuf;
3078 org.unicode = TRUE;
3079 org.str.w = lpOrgNameBuf;
3080 serial.unicode = TRUE;
3081 serial.str.w = lpSerialBuf;
3082
3083 return MSI_GetUserInfo( szProduct, &user, pcchUserNameBuf,
3084 &org, pcchOrgNameBuf,
3085 &serial, pcchSerialBuf );
3086 }
3087
3088 USERINFOSTATE WINAPI MsiGetUserInfoA(LPCSTR szProduct,
3089 LPSTR lpUserNameBuf, LPDWORD pcchUserNameBuf,
3090 LPSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
3091 LPSTR lpSerialBuf, LPDWORD pcchSerialBuf)
3092 {
3093 awstring user, org, serial;
3094 LPWSTR prod;
3095 UINT r;
3096
3097 if ((lpUserNameBuf && !pcchUserNameBuf) ||
3098 (lpOrgNameBuf && !pcchOrgNameBuf) ||
3099 (lpSerialBuf && !pcchSerialBuf))
3100 return USERINFOSTATE_INVALIDARG;
3101
3102 prod = strdupAtoW( szProduct );
3103 if (szProduct && !prod)
3104 return ERROR_OUTOFMEMORY;
3105
3106 user.unicode = FALSE;
3107 user.str.a = lpUserNameBuf;
3108 org.unicode = FALSE;
3109 org.str.a = lpOrgNameBuf;
3110 serial.unicode = FALSE;
3111 serial.str.a = lpSerialBuf;
3112
3113 r = MSI_GetUserInfo( prod, &user, pcchUserNameBuf,
3114 &org, pcchOrgNameBuf,
3115 &serial, pcchSerialBuf );
3116
3117 msi_free( prod );
3118
3119 return r;
3120 }
3121
3122 UINT WINAPI MsiCollectUserInfoW(LPCWSTR szProduct)
3123 {
3124 MSIHANDLE handle;
3125 UINT rc;
3126 MSIPACKAGE *package;
3127 static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
3128
3129 TRACE("(%s)\n",debugstr_w(szProduct));
3130
3131 rc = MsiOpenProductW(szProduct,&handle);
3132 if (rc != ERROR_SUCCESS)
3133 return ERROR_INVALID_PARAMETER;
3134
3135 /* MsiCollectUserInfo cannot be called from a custom action. */
3136 package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
3137 if (!package)
3138 return ERROR_CALL_NOT_IMPLEMENTED;
3139
3140 rc = ACTION_PerformUIAction(package, szFirstRun, -1);
3141 msiobj_release( &package->hdr );
3142
3143 MsiCloseHandle(handle);
3144
3145 return rc;
3146 }
3147
3148 UINT WINAPI MsiCollectUserInfoA(LPCSTR szProduct)
3149 {
3150 MSIHANDLE handle;
3151 UINT rc;
3152 MSIPACKAGE *package;
3153 static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
3154
3155 TRACE("(%s)\n",debugstr_a(szProduct));
3156
3157 rc = MsiOpenProductA(szProduct,&handle);
3158 if (rc != ERROR_SUCCESS)
3159 return ERROR_INVALID_PARAMETER;
3160
3161 /* MsiCollectUserInfo cannot be called from a custom action. */
3162 package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
3163 if (!package)
3164 return ERROR_CALL_NOT_IMPLEMENTED;
3165
3166 rc = ACTION_PerformUIAction(package, szFirstRun, -1);
3167 msiobj_release( &package->hdr );
3168
3169 MsiCloseHandle(handle);
3170
3171 return rc;
3172 }
3173
3174 /***********************************************************************
3175 * MsiConfigureFeatureA [MSI.@]
3176 */
3177 UINT WINAPI MsiConfigureFeatureA(LPCSTR szProduct, LPCSTR szFeature, INSTALLSTATE eInstallState)
3178 {
3179 LPWSTR prod, feat = NULL;
3180 UINT r = ERROR_OUTOFMEMORY;
3181
3182 TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature), eInstallState);
3183
3184 prod = strdupAtoW( szProduct );
3185 if (szProduct && !prod)
3186 goto end;
3187
3188 feat = strdupAtoW( szFeature );
3189 if (szFeature && !feat)
3190 goto end;
3191
3192 r = MsiConfigureFeatureW(prod, feat, eInstallState);
3193
3194 end:
3195 msi_free(feat);
3196 msi_free(prod);
3197
3198 return r;
3199 }
3200
3201 /***********************************************************************
3202 * MsiConfigureFeatureW [MSI.@]
3203 */
3204 UINT WINAPI MsiConfigureFeatureW(LPCWSTR szProduct, LPCWSTR szFeature, INSTALLSTATE eInstallState)
3205 {
3206 static const WCHAR szCostInit[] = { 'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0 };
3207 MSIPACKAGE *package = NULL;
3208 UINT r;
3209 WCHAR sourcepath[MAX_PATH], filename[MAX_PATH];
3210 DWORD sz;
3211
3212 TRACE("%s %s %i\n", debugstr_w(szProduct), debugstr_w(szFeature), eInstallState);
3213
3214 if (!szProduct || !szFeature)
3215 return ERROR_INVALID_PARAMETER;
3216
3217 switch (eInstallState)
3218 {
3219 case INSTALLSTATE_DEFAULT:
3220 /* FIXME: how do we figure out the default location? */
3221 eInstallState = INSTALLSTATE_LOCAL;
3222 break;
3223 case INSTALLSTATE_LOCAL:
3224 case INSTALLSTATE_SOURCE:
3225 case INSTALLSTATE_ABSENT:
3226 case INSTALLSTATE_ADVERTISED:
3227 break;
3228 default:
3229 return ERROR_INVALID_PARAMETER;
3230 }
3231
3232 r = MSI_OpenProductW( szProduct, &package );
3233 if (r != ERROR_SUCCESS)
3234 return r;
3235
3236 sz = sizeof