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