?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dx9: Implement ID3DXEffect::EndPass().
[wine/multimedia.git] / dlls / msi / msi.c
blob5075756ec55025094a90da4d1d0a8aea7e02921c
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 szMaxInstallLevel[] = {
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(szMaxInstallLevel);
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, szMaxInstallLevel);
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 static UINT set_drive( WCHAR *buffer, WCHAR letter )
1829 {
1830 buffer[0] = letter;
1831 buffer[1] = ':';
1832 buffer[2] = 0;
1833 return 2;
1834 }
1835
1836 UINT WINAPI MsiEnumComponentCostsW( MSIHANDLE handle, LPCWSTR component, DWORD index,
1837 INSTALLSTATE state, LPWSTR drive, DWORD *buflen,
1838 int *cost, int *temp )
1839 {
1840 UINT r = ERROR_NO_MORE_ITEMS;
1841 MSICOMPONENT *comp = NULL;
1842 MSIPACKAGE *package;
1843 MSIFILE *file;
1844 STATSTG stat = {0};
1845 WCHAR path[MAX_PATH];
1846
1847 TRACE("%d, %s, %u, %d, %p, %p, %p %p\n", handle, debugstr_w(component), index,
1848 state, drive, buflen, cost, temp);
1849
1850 if (!drive || !buflen || !cost || !temp) return ERROR_INVALID_PARAMETER;
1851 if (!(package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE )))
1852 {
1853 HRESULT hr;
1854 IWineMsiRemotePackage *remote_package;
1855 BSTR bname = NULL;
1856
1857 if (!(remote_package = (IWineMsiRemotePackage *)msi_get_remote( handle )))
1858 return ERROR_INVALID_HANDLE;
1859
1860 if (component && !(bname = SysAllocString( component )))
1861 {
1862 IWineMsiRemotePackage_Release( remote_package );
1863 return ERROR_OUTOFMEMORY;
1864 }
1865 hr = IWineMsiRemotePackage_EnumComponentCosts( remote_package, bname, index, state, drive, buflen, cost, temp );
1866 IWineMsiRemotePackage_Release( remote_package );
1867 SysFreeString( bname );
1868 if (FAILED(hr))
1869 {
1870 if (HRESULT_FACILITY(hr) == FACILITY_WIN32) return HRESULT_CODE(hr);
1871 return ERROR_FUNCTION_FAILED;
1872 }
1873 return ERROR_SUCCESS;
1874 }
1875
1876 if (!msi_get_property_int( package->db, szCostingComplete, 0 ))
1877 {
1878 msiobj_release( &package->hdr );
1879 return ERROR_FUNCTION_NOT_CALLED;
1880 }
1881 if (component && component[0] && !(comp = msi_get_loaded_component( package, component )))
1882 {
1883 msiobj_release( &package->hdr );
1884 return ERROR_UNKNOWN_COMPONENT;
1885 }
1886 if (*buflen < 3)
1887 {
1888 *buflen = 2;
1889 msiobj_release( &package->hdr );
1890 return ERROR_MORE_DATA;
1891 }
1892 if (index)
1893 {
1894 msiobj_release( &package->hdr );
1895 return ERROR_NO_MORE_ITEMS;
1896 }
1897
1898 drive[0] = 0;
1899 *cost = *temp = 0;
1900 GetWindowsDirectoryW( path, MAX_PATH );
1901 if (component && component[0])
1902 {
1903 if (comp->assembly && !comp->assembly->application) *temp = comp->Cost;
1904 if (!comp->Enabled || !comp->KeyPath)
1905 {
1906 *cost = 0;
1907 *buflen = set_drive( drive, path[0] );
1908 r = ERROR_SUCCESS;
1909 }
1910 else if ((file = msi_get_loaded_file( package, comp->KeyPath )))
1911 {
1912 *cost = max( 8, comp->Cost / 512 );
1913 *buflen = set_drive( drive, file->TargetPath[0] );
1914 r = ERROR_SUCCESS;
1915 }
1916 }
1917 else if (IStorage_Stat( package->db->storage, &stat, STATFLAG_NONAME ) == S_OK)
1918 {
1919 *temp = max( 8, stat.cbSize.QuadPart / 512 );
1920 *buflen = set_drive( drive, path[0] );
1921 r = ERROR_SUCCESS;
1922 }
1923 msiobj_release( &package->hdr );
1924 return r;
1925 }
1926
1927 UINT WINAPI MsiQueryComponentStateA(LPCSTR szProductCode,
1928 LPCSTR szUserSid, MSIINSTALLCONTEXT dwContext,
1929 LPCSTR szComponent, INSTALLSTATE *pdwState)
1930 {
1931 LPWSTR prodcode = NULL, usersid = NULL, comp = NULL;
1932 UINT r;
1933
1934 TRACE("(%s, %s, %d, %s, %p)\n", debugstr_a(szProductCode),
1935 debugstr_a(szUserSid), dwContext, debugstr_a(szComponent), pdwState);
1936
1937 if (szProductCode && !(prodcode = strdupAtoW(szProductCode)))
1938 return ERROR_OUTOFMEMORY;
1939
1940 if (szUserSid && !(usersid = strdupAtoW(szUserSid)))
1941 return ERROR_OUTOFMEMORY;
1942
1943 if (szComponent && !(comp = strdupAtoW(szComponent)))
1944 return ERROR_OUTOFMEMORY;
1945
1946 r = MsiQueryComponentStateW(prodcode, usersid, dwContext, comp, pdwState);
1947
1948 msi_free(prodcode);
1949 msi_free(usersid);
1950 msi_free(comp);
1951
1952 return r;
1953 }
1954
1955 static BOOL msi_comp_find_prod_key(LPCWSTR prodcode, MSIINSTALLCONTEXT context)
1956 {
1957 UINT r;
1958 HKEY hkey;
1959
1960 r = MSIREG_OpenProductKey(prodcode, NULL, context, &hkey, FALSE);
1961 RegCloseKey(hkey);
1962 return (r == ERROR_SUCCESS);
1963 }
1964
1965 static BOOL msi_comp_find_package(LPCWSTR prodcode, MSIINSTALLCONTEXT context)
1966 {
1967 LPCWSTR package;
1968 HKEY hkey;
1969 DWORD sz;
1970 LONG res;
1971 UINT r;
1972
1973 static const WCHAR local_package[] = {'L','o','c','a','l','P','a','c','k','a','g','e',0};
1974 static const WCHAR managed_local_package[] = {
1975 'M','a','n','a','g','e','d','L','o','c','a','l','P','a','c','k','a','g','e',0
1976 };
1977
1978 r = MSIREG_OpenInstallProps(prodcode, context, NULL, &hkey, FALSE);
1979 if (r != ERROR_SUCCESS)
1980 return FALSE;
1981
1982 if (context == MSIINSTALLCONTEXT_USERMANAGED)
1983 package = managed_local_package;
1984 else
1985 package = local_package;
1986
1987 sz = 0;
1988 res = RegQueryValueExW(hkey, package, NULL, NULL, NULL, &sz);
1989 RegCloseKey(hkey);
1990
1991 return (res == ERROR_SUCCESS);
1992 }
1993
1994 static BOOL msi_comp_find_prodcode(LPWSTR squished_pc,
1995 MSIINSTALLCONTEXT context,
1996 LPCWSTR comp, LPWSTR val, DWORD *sz)
1997 {
1998 HKEY hkey;
1999 LONG res;
2000 UINT r;
2001
2002 if (context == MSIINSTALLCONTEXT_MACHINE)
2003 r = MSIREG_OpenUserDataComponentKey(comp, szLocalSid, &hkey, FALSE);
2004 else
2005 r = MSIREG_OpenUserDataComponentKey(comp, NULL, &hkey, FALSE);
2006
2007 if (r != ERROR_SUCCESS)
2008 return FALSE;
2009
2010 res = RegQueryValueExW(hkey, squished_pc, NULL, NULL, (BYTE *)val, sz);
2011 if (res != ERROR_SUCCESS)
2012 return FALSE;
2013
2014 RegCloseKey(hkey);
2015 return TRUE;
2016 }
2017
2018 UINT WINAPI MsiQueryComponentStateW(LPCWSTR szProductCode,
2019 LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext,
2020 LPCWSTR szComponent, INSTALLSTATE *pdwState)
2021 {
2022 WCHAR squished_pc[GUID_SIZE];
2023 WCHAR val[MAX_PATH];
2024 BOOL found;
2025 DWORD sz;
2026
2027 TRACE("(%s, %s, %d, %s, %p)\n", debugstr_w(szProductCode),
2028 debugstr_w(szUserSid), dwContext, debugstr_w(szComponent), pdwState);
2029
2030 if (!pdwState || !szComponent)
2031 return ERROR_INVALID_PARAMETER;
2032
2033 if (!szProductCode || !*szProductCode || lstrlenW(szProductCode) != GUID_SIZE - 1)
2034 return ERROR_INVALID_PARAMETER;
2035
2036 if (!squash_guid(szProductCode, squished_pc))
2037 return ERROR_INVALID_PARAMETER;
2038
2039 found = msi_comp_find_prod_key(szProductCode, dwContext);
2040
2041 if (!msi_comp_find_package(szProductCode, dwContext))
2042 {
2043 if (found)
2044 {
2045 *pdwState = INSTALLSTATE_UNKNOWN;
2046 return ERROR_UNKNOWN_COMPONENT;
2047 }
2048
2049 return ERROR_UNKNOWN_PRODUCT;
2050 }
2051
2052 *pdwState = INSTALLSTATE_UNKNOWN;
2053
2054 sz = MAX_PATH;
2055 if (!msi_comp_find_prodcode(squished_pc, dwContext, szComponent, val, &sz))
2056 return ERROR_UNKNOWN_COMPONENT;
2057
2058 if (sz == 0)
2059 *pdwState = INSTALLSTATE_NOTUSED;
2060 else
2061 {
2062 if (lstrlenW(val) > 2 &&
2063 val[0] >= '0' && val[0] <= '9' && val[1] >= '0' && val[1] <= '9')
2064 {
2065 *pdwState = INSTALLSTATE_SOURCE;
2066 }
2067 else
2068 *pdwState = INSTALLSTATE_LOCAL;
2069 }
2070
2071 TRACE("-> %d\n", *pdwState);
2072 return ERROR_SUCCESS;
2073 }
2074
2075 INSTALLSTATE WINAPI MsiQueryProductStateA(LPCSTR szProduct)
2076 {
2077 LPWSTR szwProduct = NULL;
2078 INSTALLSTATE r;
2079
2080 if( szProduct )
2081 {
2082 szwProduct = strdupAtoW( szProduct );
2083 if( !szwProduct )
2084 return ERROR_OUTOFMEMORY;
2085 }
2086 r = MsiQueryProductStateW( szwProduct );
2087 msi_free( szwProduct );
2088 return r;
2089 }
2090
2091 INSTALLSTATE WINAPI MsiQueryProductStateW(LPCWSTR szProduct)
2092 {
2093 MSIINSTALLCONTEXT context = MSIINSTALLCONTEXT_USERUNMANAGED;
2094 INSTALLSTATE state = INSTALLSTATE_ADVERTISED;
2095 HKEY prodkey = 0, userdata = 0;
2096 DWORD val;
2097 UINT r;
2098
2099 TRACE("%s\n", debugstr_w(szProduct));
2100
2101 if (!szProduct || !*szProduct)
2102 return INSTALLSTATE_INVALIDARG;
2103
2104 if (lstrlenW(szProduct) != GUID_SIZE - 1)
2105 return INSTALLSTATE_INVALIDARG;
2106
2107 if (szProduct[0] != '{' || szProduct[37] != '}')
2108 return INSTALLSTATE_UNKNOWN;
2109
2110 SetLastError( ERROR_SUCCESS );
2111
2112 if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
2113 &prodkey, FALSE) != ERROR_SUCCESS &&
2114 MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2115 &prodkey, FALSE) != ERROR_SUCCESS &&
2116 MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
2117 &prodkey, FALSE) == ERROR_SUCCESS)
2118 {
2119 context = MSIINSTALLCONTEXT_MACHINE;
2120 }
2121
2122 r = MSIREG_OpenInstallProps(szProduct, context, NULL, &userdata, FALSE);
2123 if (r != ERROR_SUCCESS)
2124 goto done;
2125
2126 if (!msi_reg_get_val_dword(userdata, szWindowsInstaller, &val))
2127 goto done;
2128
2129 if (val)
2130 state = INSTALLSTATE_DEFAULT;
2131 else
2132 state = INSTALLSTATE_UNKNOWN;
2133
2134 done:
2135 if (!prodkey)
2136 {
2137 state = INSTALLSTATE_UNKNOWN;
2138
2139 if (userdata)
2140 state = INSTALLSTATE_ABSENT;
2141 }
2142
2143 RegCloseKey(prodkey);
2144 RegCloseKey(userdata);
2145 TRACE("-> %d\n", state);
2146 return state;
2147 }
2148
2149 INSTALLUILEVEL WINAPI MsiSetInternalUI(INSTALLUILEVEL dwUILevel, HWND *phWnd)
2150 {
2151 INSTALLUILEVEL old = gUILevel;
2152 HWND oldwnd = gUIhwnd;
2153
2154 TRACE("%08x %p\n", dwUILevel, phWnd);
2155
2156 gUILevel = dwUILevel;
2157 if (phWnd)
2158 {
2159 gUIhwnd = *phWnd;
2160 *phWnd = oldwnd;
2161 }
2162 return old;
2163 }
2164
2165 INSTALLUI_HANDLERA WINAPI MsiSetExternalUIA(INSTALLUI_HANDLERA puiHandler,
2166 DWORD dwMessageFilter, LPVOID pvContext)
2167 {
2168 INSTALLUI_HANDLERA prev = gUIHandlerA;
2169
2170 TRACE("%p %08x %p\n", puiHandler, dwMessageFilter, pvContext);
2171
2172 gUIHandlerA = puiHandler;
2173 gUIHandlerW = NULL;
2174 gUIFilter = dwMessageFilter;
2175 gUIContext = pvContext;
2176
2177 return prev;
2178 }
2179
2180 INSTALLUI_HANDLERW WINAPI MsiSetExternalUIW(INSTALLUI_HANDLERW puiHandler,
2181 DWORD dwMessageFilter, LPVOID pvContext)
2182 {
2183 INSTALLUI_HANDLERW prev = gUIHandlerW;
2184
2185 TRACE("%p %08x %p\n", puiHandler, dwMessageFilter, pvContext);
2186
2187 gUIHandlerA = NULL;
2188 gUIHandlerW = puiHandler;
2189 gUIFilter = dwMessageFilter;
2190 gUIContext = pvContext;
2191
2192 return prev;
2193 }
2194
2195 /******************************************************************
2196 * MsiLoadStringW [MSI.@]
2197 *
2198 * Loads a string from MSI's string resources.
2199 *
2200 * PARAMS
2201 *
2202 * handle [I] only -1 is handled currently
2203 * id [I] id of the string to be loaded
2204 * lpBuffer [O] buffer for the string to be written to
2205 * nBufferMax [I] maximum size of the buffer in characters
2206 * lang [I] the preferred language for the string
2207 *
2208 * RETURNS
2209 *
2210 * If successful, this function returns the language id of the string loaded
2211 * If the function fails, the function returns zero.
2212 *
2213 * NOTES
2214 *
2215 * The type of the first parameter is unknown. LoadString's prototype
2216 * suggests that it might be a module handle. I have made it an MSI handle
2217 * for starters, as -1 is an invalid MSI handle, but not an invalid module
2218 * handle. Maybe strings can be stored in an MSI database somehow.
2219 */
2220 LANGID WINAPI MsiLoadStringW( MSIHANDLE handle, UINT id, LPWSTR lpBuffer,
2221 int nBufferMax, LANGID lang )
2222 {
2223 HRSRC hres;
2224 HGLOBAL hResData;
2225 LPWSTR p;
2226 DWORD i, len;
2227
2228 TRACE("%d %u %p %d %d\n", handle, id, lpBuffer, nBufferMax, lang);
2229
2230 if( handle != -1 )
2231 FIXME("don't know how to deal with handle = %08x\n", handle);
2232
2233 if( !lang )
2234 lang = GetUserDefaultLangID();
2235
2236 hres = FindResourceExW( msi_hInstance, (LPCWSTR) RT_STRING,
2237 (LPWSTR)1, lang );
2238 if( !hres )
2239 return 0;
2240 hResData = LoadResource( msi_hInstance, hres );
2241 if( !hResData )
2242 return 0;
2243 p = LockResource( hResData );
2244 if( !p )
2245 return 0;
2246
2247 for (i = 0; i < (id&0xf); i++)
2248 p += *p + 1;
2249 len = *p;
2250
2251 if( nBufferMax <= len )
2252 return 0;
2253
2254 memcpy( lpBuffer, p+1, len * sizeof(WCHAR));
2255 lpBuffer[ len ] = 0;
2256
2257 TRACE("found -> %s\n", debugstr_w(lpBuffer));
2258
2259 return lang;
2260 }
2261
2262 LANGID WINAPI MsiLoadStringA( MSIHANDLE handle, UINT id, LPSTR lpBuffer,
2263 int nBufferMax, LANGID lang )
2264 {
2265 LPWSTR bufW;
2266 LANGID r;
2267 INT len;
2268
2269 bufW = msi_alloc(nBufferMax*sizeof(WCHAR));
2270 r = MsiLoadStringW(handle, id, bufW, nBufferMax, lang);
2271 if( r )
2272 {
2273 len = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL, NULL );
2274 if( len <= nBufferMax )
2275 WideCharToMultiByte( CP_ACP, 0, bufW, -1,
2276 lpBuffer, nBufferMax, NULL, NULL );
2277 else
2278 r = 0;
2279 }
2280 msi_free(bufW);
2281 return r;
2282 }
2283
2284 INSTALLSTATE WINAPI MsiLocateComponentA(LPCSTR szComponent, LPSTR lpPathBuf,
2285 LPDWORD pcchBuf)
2286 {
2287 char szProduct[GUID_SIZE];
2288
2289 TRACE("%s %p %p\n", debugstr_a(szComponent), lpPathBuf, pcchBuf);
2290
2291 if (!szComponent || !pcchBuf)
2292 return INSTALLSTATE_INVALIDARG;
2293
2294 if (MsiGetProductCodeA( szComponent, szProduct ) != ERROR_SUCCESS)
2295 return INSTALLSTATE_UNKNOWN;
2296
2297 return MsiGetComponentPathA( szProduct, szComponent, lpPathBuf, pcchBuf );
2298 }
2299
2300 INSTALLSTATE WINAPI MsiLocateComponentW(LPCWSTR szComponent, LPWSTR lpPathBuf,
2301 LPDWORD pcchBuf)
2302 {
2303 WCHAR szProduct[GUID_SIZE];
2304
2305 TRACE("%s %p %p\n", debugstr_w(szComponent), lpPathBuf, pcchBuf);
2306
2307 if (!szComponent || !pcchBuf)
2308 return INSTALLSTATE_INVALIDARG;
2309
2310 if (MsiGetProductCodeW( szComponent, szProduct ) != ERROR_SUCCESS)
2311 return INSTALLSTATE_UNKNOWN;
2312
2313 return MsiGetComponentPathW( szProduct, szComponent, lpPathBuf, pcchBuf );
2314 }
2315
2316 UINT WINAPI MsiMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,
2317 WORD wLanguageId, DWORD f)
2318 {
2319 FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_a(lpText), debugstr_a(lpCaption),
2320 uType, wLanguageId, f);
2321 return MessageBoxExA(hWnd,lpText,lpCaption,uType,wLanguageId);
2322 }
2323
2324 UINT WINAPI MsiMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,
2325 WORD wLanguageId, DWORD f)
2326 {
2327 FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_w(lpText), debugstr_w(lpCaption),
2328 uType, wLanguageId, f);
2329 return MessageBoxExW(hWnd,lpText,lpCaption,uType,wLanguageId);
2330 }
2331
2332 UINT WINAPI MsiMessageBoxExA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,
2333 DWORD unknown, WORD wLanguageId, DWORD f)
2334 {
2335 FIXME("(%p, %s, %s, %u, 0x%08x, 0x%08x, 0x%08x): semi-stub\n", hWnd, debugstr_a(lpText),
2336 debugstr_a(lpCaption), uType, unknown, wLanguageId, f);
2337 return MessageBoxExA(hWnd, lpText, lpCaption, uType, wLanguageId);
2338 }
2339
2340 UINT WINAPI MsiMessageBoxExW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,
2341 DWORD unknown, WORD wLanguageId, DWORD f)
2342 {
2343 FIXME("(%p, %s, %s, %u, 0x%08x, 0x%08x, 0x%08x): semi-stub\n", hWnd, debugstr_w(lpText),
2344 debugstr_w(lpCaption), uType, unknown, wLanguageId, f);
2345 return MessageBoxExW(hWnd, lpText, lpCaption, uType, wLanguageId);
2346 }
2347
2348 UINT WINAPI MsiProvideAssemblyA( LPCSTR szAssemblyName, LPCSTR szAppContext,
2349 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPSTR lpPathBuf,
2350 LPDWORD pcchPathBuf )
2351 {
2352 FIXME("%s %s %08x %08x %p %p\n", debugstr_a(szAssemblyName),
2353 debugstr_a(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
2354 pcchPathBuf);
2355 return ERROR_CALL_NOT_IMPLEMENTED;
2356 }
2357
2358 UINT WINAPI MsiProvideAssemblyW( LPCWSTR szAssemblyName, LPCWSTR szAppContext,
2359 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPWSTR lpPathBuf,
2360 LPDWORD pcchPathBuf )
2361 {
2362 FIXME("%s %s %08x %08x %p %p\n", debugstr_w(szAssemblyName),
2363 debugstr_w(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
2364 pcchPathBuf);
2365 return ERROR_CALL_NOT_IMPLEMENTED;
2366 }
2367
2368 UINT WINAPI MsiProvideComponentFromDescriptorA( LPCSTR szDescriptor,
2369 LPSTR szPath, LPDWORD pcchPath, LPDWORD pcchArgs )
2370 {
2371 FIXME("%s %p %p %p\n", debugstr_a(szDescriptor), szPath, pcchPath, pcchArgs );
2372 return ERROR_CALL_NOT_IMPLEMENTED;
2373 }
2374
2375 UINT WINAPI MsiProvideComponentFromDescriptorW( LPCWSTR szDescriptor,
2376 LPWSTR szPath, LPDWORD pcchPath, LPDWORD pcchArgs )
2377 {
2378 FIXME("%s %p %p %p\n", debugstr_w(szDescriptor), szPath, pcchPath, pcchArgs );
2379 return ERROR_CALL_NOT_IMPLEMENTED;
2380 }
2381
2382 HRESULT WINAPI MsiGetFileSignatureInformationA( LPCSTR path, DWORD flags, PCCERT_CONTEXT *cert,
2383 LPBYTE hash, LPDWORD hashlen )
2384 {
2385 UINT r;
2386 WCHAR *pathW = NULL;
2387
2388 TRACE("%s %08x %p %p %p\n", debugstr_a(path), flags, cert, hash, hashlen);
2389
2390 if (path && !(pathW = strdupAtoW( path ))) return ERROR_OUTOFMEMORY;
2391 r = MsiGetFileSignatureInformationW( pathW, flags, cert, hash, hashlen );
2392 msi_free( pathW );
2393 return r;
2394 }
2395
2396 HRESULT WINAPI MsiGetFileSignatureInformationW( LPCWSTR path, DWORD flags, PCCERT_CONTEXT *cert,
2397 LPBYTE hash, LPDWORD hashlen )
2398 {
2399 static GUID generic_verify_v2 = WINTRUST_ACTION_GENERIC_VERIFY_V2;
2400 HRESULT hr;
2401 WINTRUST_DATA data;
2402 WINTRUST_FILE_INFO info;
2403 CRYPT_PROVIDER_SGNR *signer;
2404 CRYPT_PROVIDER_CERT *provider;
2405
2406 TRACE("%s %08x %p %p %p\n", debugstr_w(path), flags, cert, hash, hashlen);
2407
2408 if (!path || !cert) return E_INVALIDARG;
2409
2410 info.cbStruct = sizeof(info);
2411 info.pcwszFilePath = path;
2412 info.hFile = NULL;
2413 info.pgKnownSubject = NULL;
2414
2415 data.cbStruct = sizeof(data);
2416 data.pPolicyCallbackData = NULL;
2417 data.pSIPClientData = NULL;
2418 data.dwUIChoice = WTD_UI_NONE;
2419 data.fdwRevocationChecks = WTD_REVOKE_WHOLECHAIN;
2420 data.dwUnionChoice = WTD_CHOICE_FILE;
2421 data.u.pFile = &info;
2422 data.dwStateAction = WTD_STATEACTION_VERIFY;
2423 data.hWVTStateData = NULL;
2424 data.pwszURLReference = NULL;
2425 data.dwProvFlags = 0;
2426 data.dwUIContext = WTD_UICONTEXT_INSTALL;
2427 hr = WinVerifyTrustEx( INVALID_HANDLE_VALUE, &generic_verify_v2, &data );
2428 if (FAILED(hr)) goto done;
2429
2430 if (!(signer = WTHelperGetProvSignerFromChain( data.hWVTStateData, 0, FALSE, 0 )))
2431 {
2432 hr = TRUST_E_NOSIGNATURE;
2433 goto done;
2434 }
2435 if (hash)
2436 {
2437 DWORD len = signer->psSigner->EncryptedHash.cbData;
2438 if (*hashlen < len)
2439 {
2440 *hashlen = len;
2441 hr = HRESULT_FROM_WIN32(ERROR_MORE_DATA);
2442 goto done;
2443 }
2444 memcpy( hash, signer->psSigner->EncryptedHash.pbData, len );
2445 *hashlen = len;
2446 }
2447 if (!(provider = WTHelperGetProvCertFromChain( signer, 0 )))
2448 {
2449 hr = TRUST_E_PROVIDER_UNKNOWN;
2450 goto done;
2451 }
2452 *cert = CertDuplicateCertificateContext( provider->pCert );
2453
2454 done:
2455 data.dwStateAction = WTD_STATEACTION_CLOSE;
2456 WinVerifyTrustEx( INVALID_HANDLE_VALUE, &generic_verify_v2, &data );
2457 return hr;
2458 }
2459
2460 /******************************************************************
2461 * MsiGetProductPropertyA [MSI.@]
2462 */
2463 UINT WINAPI MsiGetProductPropertyA(MSIHANDLE hProduct, LPCSTR szProperty,
2464 LPSTR szValue, LPDWORD pccbValue)
2465 {
2466 LPWSTR prop = NULL, val = NULL;
2467 DWORD len;
2468 UINT r;
2469
2470 TRACE("(%d, %s, %p, %p)\n", hProduct, debugstr_a(szProperty),
2471 szValue, pccbValue);
2472
2473 if (szValue && !pccbValue)
2474 return ERROR_INVALID_PARAMETER;
2475
2476 if (szProperty) prop = strdupAtoW(szProperty);
2477
2478 len = 0;
2479 r = MsiGetProductPropertyW(hProduct, prop, NULL, &len);
2480 if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
2481 goto done;
2482
2483 if (r == ERROR_SUCCESS)
2484 {
2485 if (szValue) *szValue = '\0';
2486 if (pccbValue) *pccbValue = 0;
2487 goto done;
2488 }
2489
2490 val = msi_alloc(++len * sizeof(WCHAR));
2491 if (!val)
2492 {
2493 r = ERROR_OUTOFMEMORY;
2494 goto done;
2495 }
2496
2497 r = MsiGetProductPropertyW(hProduct, prop, val, &len);
2498 if (r != ERROR_SUCCESS)
2499 goto done;
2500
2501 len = WideCharToMultiByte(CP_ACP, 0, val, -1, NULL, 0, NULL, NULL);
2502
2503 if (szValue)
2504 WideCharToMultiByte(CP_ACP, 0, val, -1, szValue,
2505 *pccbValue, NULL, NULL);
2506
2507 if (pccbValue)
2508 {
2509 if (len > *pccbValue)
2510 r = ERROR_MORE_DATA;
2511
2512 *pccbValue = len - 1;
2513 }
2514
2515 done:
2516 msi_free(prop);
2517 msi_free(val);
2518
2519 return r;
2520 }
2521
2522 /******************************************************************
2523 * MsiGetProductPropertyW [MSI.@]
2524 */
2525 UINT WINAPI MsiGetProductPropertyW(MSIHANDLE hProduct, LPCWSTR szProperty,
2526 LPWSTR szValue, LPDWORD pccbValue)
2527 {
2528 MSIPACKAGE *package;
2529 MSIQUERY *view = NULL;
2530 MSIRECORD *rec = NULL;
2531 LPCWSTR val;
2532 UINT r;
2533
2534 static const WCHAR query[] = {
2535 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
2536 '`','P','r','o','p','e','r','t','y','`',' ','W','H','E','R','E',' ',
2537 '`','P','r','o','p','e','r','t','y','`','=','\'','%','s','\'',0};
2538
2539 TRACE("(%d, %s, %p, %p)\n", hProduct, debugstr_w(szProperty),
2540 szValue, pccbValue);
2541
2542 if (!szProperty)
2543 return ERROR_INVALID_PARAMETER;
2544
2545 if (szValue && !pccbValue)
2546 return ERROR_INVALID_PARAMETER;
2547
2548 package = msihandle2msiinfo(hProduct, MSIHANDLETYPE_PACKAGE);
2549 if (!package)
2550 return ERROR_INVALID_HANDLE;
2551
2552 r = MSI_OpenQuery(package->db, &view, query, szProperty);
2553 if (r != ERROR_SUCCESS)
2554 goto done;
2555
2556 r = MSI_ViewExecute(view, 0);
2557 if (r != ERROR_SUCCESS)
2558 goto done;
2559
2560 r = MSI_ViewFetch(view, &rec);
2561 if (r != ERROR_SUCCESS)
2562 goto done;
2563
2564 val = MSI_RecordGetString(rec, 2);
2565 if (!val)
2566 goto done;
2567
2568 if (lstrlenW(val) >= *pccbValue)
2569 {
2570 lstrcpynW(szValue, val, *pccbValue);
2571 *pccbValue = lstrlenW(val);
2572 r = ERROR_MORE_DATA;
2573 }
2574 else
2575 {
2576 lstrcpyW(szValue, val);
2577 *pccbValue = lstrlenW(val);
2578 r = ERROR_SUCCESS;
2579 }
2580
2581 done:
2582 if (view)
2583 {
2584 MSI_ViewClose(view);
2585 msiobj_release(&view->hdr);
2586 if (rec) msiobj_release(&rec->hdr);
2587 }
2588
2589 if (!rec)
2590 {
2591 if (szValue) *szValue = '\0';
2592 if (pccbValue) *pccbValue = 0;
2593 r = ERROR_SUCCESS;
2594 }
2595
2596 msiobj_release(&package->hdr);
2597 return r;
2598 }
2599
2600 UINT WINAPI MsiVerifyPackageA( LPCSTR szPackage )
2601 {
2602 UINT r;
2603 LPWSTR szPack = NULL;
2604
2605 TRACE("%s\n", debugstr_a(szPackage) );
2606
2607 if( szPackage )
2608 {
2609 szPack = strdupAtoW( szPackage );
2610 if( !szPack )
2611 return ERROR_OUTOFMEMORY;
2612 }
2613
2614 r = MsiVerifyPackageW( szPack );
2615
2616 msi_free( szPack );
2617
2618 return r;
2619 }
2620
2621 UINT WINAPI MsiVerifyPackageW( LPCWSTR szPackage )
2622 {
2623 MSIHANDLE handle;
2624 UINT r;
2625
2626 TRACE("%s\n", debugstr_w(szPackage) );
2627
2628 r = MsiOpenDatabaseW( szPackage, MSIDBOPEN_READONLY, &handle );
2629 MsiCloseHandle( handle );
2630
2631 return r;
2632 }
2633
2634 static INSTALLSTATE MSI_GetComponentPath(LPCWSTR szProduct, LPCWSTR szComponent,
2635 awstring* lpPathBuf, LPDWORD pcchBuf)
2636 {
2637 WCHAR squished_pc[GUID_SIZE];
2638 WCHAR squished_comp[GUID_SIZE];
2639 HKEY hkey;
2640 LPWSTR path = NULL;
2641 INSTALLSTATE state;
2642 DWORD version;
2643
2644 static const WCHAR wininstaller[] = {
2645 'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
2646
2647 TRACE("%s %s %p %p\n", debugstr_w(szProduct),
2648 debugstr_w(szComponent), lpPathBuf->str.w, pcchBuf);
2649
2650 if (!szProduct || !szComponent)
2651 return INSTALLSTATE_INVALIDARG;
2652
2653 if (lpPathBuf->str.w && !pcchBuf)
2654 return INSTALLSTATE_INVALIDARG;
2655
2656 if (!squash_guid(szProduct, squished_pc) ||
2657 !squash_guid(szComponent, squished_comp))
2658 return INSTALLSTATE_INVALIDARG;
2659
2660 state = INSTALLSTATE_UNKNOWN;
2661
2662 if (MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkey, FALSE) == ERROR_SUCCESS ||
2663 MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkey, FALSE) == ERROR_SUCCESS)
2664 {
2665 path = msi_reg_get_val_str(hkey, squished_pc);
2666 RegCloseKey(hkey);
2667
2668 state = INSTALLSTATE_ABSENT;
2669
2670 if ((MSIREG_OpenInstallProps(szProduct, MSIINSTALLCONTEXT_MACHINE, NULL,
2671 &hkey, FALSE) == ERROR_SUCCESS ||
2672 MSIREG_OpenUserDataProductKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
2673 NULL, &hkey, FALSE) == ERROR_SUCCESS) &&
2674 msi_reg_get_val_dword(hkey, wininstaller, &version) &&
2675 GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
2676 {
2677 RegCloseKey(hkey);
2678 state = INSTALLSTATE_LOCAL;
2679 }
2680 }
2681
2682 if (state != INSTALLSTATE_LOCAL &&
2683 (MSIREG_OpenProductKey(szProduct, NULL,
2684 MSIINSTALLCONTEXT_USERUNMANAGED,
2685 &hkey, FALSE) == ERROR_SUCCESS ||
2686 MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
2687 &hkey, FALSE) == ERROR_SUCCESS))
2688 {
2689 RegCloseKey(hkey);
2690
2691 if (MSIREG_OpenUserDataComponentKey(szComponent, szLocalSid, &hkey, FALSE) == ERROR_SUCCESS ||
2692 MSIREG_OpenUserDataComponentKey(szComponent, NULL, &hkey, FALSE) == ERROR_SUCCESS)
2693 {
2694 msi_free(path);
2695 path = msi_reg_get_val_str(hkey, squished_pc);
2696 RegCloseKey(hkey);
2697
2698 state = INSTALLSTATE_ABSENT;
2699
2700 if (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
2701 state = INSTALLSTATE_LOCAL;
2702 }
2703 }
2704
2705 if (!path)
2706 return INSTALLSTATE_UNKNOWN;
2707
2708 if (state == INSTALLSTATE_LOCAL && !*path)
2709 state = INSTALLSTATE_NOTUSED;
2710
2711 msi_strcpy_to_awstring(path, lpPathBuf, pcchBuf);
2712 msi_free(path);
2713 return state;
2714 }
2715
2716 /******************************************************************
2717 * MsiGetComponentPathW [MSI.@]
2718 */
2719 INSTALLSTATE WINAPI MsiGetComponentPathW(LPCWSTR szProduct, LPCWSTR szComponent,
2720 LPWSTR lpPathBuf, LPDWORD pcchBuf)
2721 {
2722 awstring path;
2723
2724 path.unicode = TRUE;
2725 path.str.w = lpPathBuf;
2726
2727 return MSI_GetComponentPath( szProduct, szComponent, &path, pcchBuf );
2728 }
2729
2730 /******************************************************************
2731 * MsiGetComponentPathA [MSI.@]
2732 */
2733 INSTALLSTATE WINAPI MsiGetComponentPathA(LPCSTR szProduct, LPCSTR szComponent,
2734 LPSTR lpPathBuf, LPDWORD pcchBuf)
2735 {
2736 LPWSTR szwProduct, szwComponent = NULL;
2737 INSTALLSTATE r = INSTALLSTATE_UNKNOWN;
2738 awstring path;
2739
2740 szwProduct = strdupAtoW( szProduct );
2741 if( szProduct && !szwProduct)
2742 goto end;
2743
2744 szwComponent = strdupAtoW( szComponent );
2745 if( szComponent && !szwComponent )
2746 goto end;
2747
2748 path.unicode = FALSE;
2749 path.str.a = lpPathBuf;
2750
2751 r = MSI_GetComponentPath( szwProduct, szwComponent, &path, pcchBuf );
2752
2753 end:
2754 msi_free( szwProduct );
2755 msi_free( szwComponent );
2756
2757 return r;
2758 }
2759
2760 /******************************************************************
2761 * MsiQueryFeatureStateA [MSI.@]
2762 */
2763 INSTALLSTATE WINAPI MsiQueryFeatureStateA(LPCSTR szProduct, LPCSTR szFeature)
2764 {
2765 LPWSTR szwProduct = NULL, szwFeature= NULL;
2766 INSTALLSTATE rc = INSTALLSTATE_UNKNOWN;
2767
2768 szwProduct = strdupAtoW( szProduct );
2769 if ( szProduct && !szwProduct )
2770 goto end;
2771
2772 szwFeature = strdupAtoW( szFeature );
2773 if ( szFeature && !szwFeature )
2774 goto end;
2775
2776 rc = MsiQueryFeatureStateW(szwProduct, szwFeature);
2777
2778 end:
2779 msi_free( szwProduct);
2780 msi_free( szwFeature);
2781
2782 return rc;
2783 }
2784
2785 /******************************************************************
2786 * MsiQueryFeatureStateW [MSI.@]
2787 *
2788 * Checks the state of a feature
2789 *
2790 * PARAMS
2791 * szProduct [I] Product's GUID string
2792 * szFeature [I] Feature's GUID string
2793 *
2794 * RETURNS
2795 * INSTALLSTATE_LOCAL Feature is installed and usable
2796 * INSTALLSTATE_ABSENT Feature is absent
2797 * INSTALLSTATE_ADVERTISED Feature should be installed on demand
2798 * INSTALLSTATE_UNKNOWN An error occurred
2799 * INSTALLSTATE_INVALIDARG One of the GUIDs was invalid
2800 *
2801 */
2802 INSTALLSTATE WINAPI MsiQueryFeatureStateW(LPCWSTR szProduct, LPCWSTR szFeature)
2803 {
2804 WCHAR squishProduct[33], comp[GUID_SIZE];
2805 GUID guid;
2806 LPWSTR components, p, parent_feature, path;
2807 UINT rc;
2808 HKEY hkey;
2809 INSTALLSTATE r;
2810 BOOL missing = FALSE;
2811 BOOL machine = FALSE;
2812 BOOL source = FALSE;
2813
2814 TRACE("%s %s\n", debugstr_w(szProduct), debugstr_w(szFeature));
2815
2816 if (!szProduct || !szFeature)
2817 return INSTALLSTATE_INVALIDARG;
2818
2819 if (!squash_guid( szProduct, squishProduct ))
2820 return INSTALLSTATE_INVALIDARG;
2821
2822 SetLastError( ERROR_SUCCESS );
2823
2824 if (MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_USERMANAGED,
2825 &hkey, FALSE) != ERROR_SUCCESS &&
2826 MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
2827 &hkey, FALSE) != ERROR_SUCCESS)
2828 {
2829 rc = MSIREG_OpenFeaturesKey(szProduct, MSIINSTALLCONTEXT_MACHINE,
2830 &hkey, FALSE);
2831 if (rc != ERROR_SUCCESS)
2832 return INSTALLSTATE_UNKNOWN;
2833
2834 machine = TRUE;
2835 }
2836
2837 parent_feature = msi_reg_get_val_str( hkey, szFeature );
2838 RegCloseKey(hkey);
2839
2840 if (!parent_feature)
2841 return INSTALLSTATE_UNKNOWN;
2842
2843 r = (parent_feature[0] == 6) ? INSTALLSTATE_ABSENT : INSTALLSTATE_LOCAL;
2844 msi_free(parent_feature);
2845 if (r == INSTALLSTATE_ABSENT)
2846 return r;
2847
2848 if (machine)
2849 rc = MSIREG_OpenUserDataFeaturesKey(szProduct,
2850 MSIINSTALLCONTEXT_MACHINE,
2851 &hkey, FALSE);
2852 else
2853 rc = MSIREG_OpenUserDataFeaturesKey(szProduct,
2854 MSIINSTALLCONTEXT_USERUNMANAGED,
2855 &hkey, FALSE);
2856
2857 if (rc != ERROR_SUCCESS)
2858 return INSTALLSTATE_ADVERTISED;
2859
2860 components = msi_reg_get_val_str( hkey, szFeature );
2861 RegCloseKey(hkey);
2862
2863 TRACE("rc = %d buffer = %s\n", rc, debugstr_w(components));
2864
2865 if (!components)
2866 return INSTALLSTATE_ADVERTISED;
2867
2868 for( p = components; *p && *p != 2 ; p += 20)
2869 {
2870 if (!decode_base85_guid( p, &guid ))
2871 {
2872 if (p != components)
2873 break;
2874
2875 msi_free(components);
2876 return INSTALLSTATE_BADCONFIG;
2877 }
2878
2879 StringFromGUID2(&guid, comp, GUID_SIZE);
2880
2881 if (machine)
2882 rc = MSIREG_OpenUserDataComponentKey(comp, szLocalSid, &hkey, FALSE);
2883 else
2884 rc = MSIREG_OpenUserDataComponentKey(comp, NULL, &hkey, FALSE);
2885
2886 if (rc != ERROR_SUCCESS)
2887 {
2888 msi_free(components);
2889 return INSTALLSTATE_ADVERTISED;
2890 }
2891
2892 path = msi_reg_get_val_str(hkey, squishProduct);
2893 if (!path)
2894 missing = TRUE;
2895 else if (lstrlenW(path) > 2 &&
2896 path[0] >= '0' && path[0] <= '9' &&
2897 path[1] >= '0' && path[1] <= '9')
2898 {
2899 source = TRUE;
2900 }
2901
2902 msi_free(path);
2903 }
2904 msi_free(components);
2905
2906 if (missing)
2907 r = INSTALLSTATE_ADVERTISED;
2908 else if (source)
2909 r = INSTALLSTATE_SOURCE;
2910 else
2911 r = INSTALLSTATE_LOCAL;
2912
2913 TRACE("-> %d\n", r);
2914 return r;
2915 }
2916
2917 /******************************************************************
2918 * MsiGetFileVersionA [MSI.@]
2919 */
2920 UINT WINAPI MsiGetFileVersionA(LPCSTR szFilePath, LPSTR lpVersionBuf,
2921 LPDWORD pcchVersionBuf, LPSTR lpLangBuf, LPDWORD pcchLangBuf)
2922 {
2923 LPWSTR szwFilePath = NULL, lpwVersionBuff = NULL, lpwLangBuff = NULL;
2924 UINT ret = ERROR_OUTOFMEMORY;
2925
2926 if ((lpVersionBuf && !pcchVersionBuf) ||
2927 (lpLangBuf && !pcchLangBuf))
2928 return ERROR_INVALID_PARAMETER;
2929
2930 if( szFilePath )
2931 {
2932 szwFilePath = strdupAtoW( szFilePath );
2933 if( !szwFilePath )
2934 goto end;
2935 }
2936
2937 if( lpVersionBuf && pcchVersionBuf && *pcchVersionBuf )
2938 {
2939 lpwVersionBuff = msi_alloc(*pcchVersionBuf*sizeof(WCHAR));
2940 if( !lpwVersionBuff )
2941 goto end;
2942 }
2943
2944 if( lpLangBuf && pcchLangBuf && *pcchLangBuf )
2945 {
2946 lpwLangBuff = msi_alloc(*pcchLangBuf*sizeof(WCHAR));
2947 if( !lpwLangBuff )
2948 goto end;
2949 }
2950
2951 ret = MsiGetFileVersionW(szwFilePath, lpwVersionBuff, pcchVersionBuf,
2952 lpwLangBuff, pcchLangBuf);
2953
2954 if( (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && lpwVersionBuff )
2955 WideCharToMultiByte(CP_ACP, 0, lpwVersionBuff, -1,
2956 lpVersionBuf, *pcchVersionBuf + 1, NULL, NULL);
2957 if( (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && lpwLangBuff )
2958 WideCharToMultiByte(CP_ACP, 0, lpwLangBuff, -1,
2959 lpLangBuf, *pcchLangBuf + 1, NULL, NULL);
2960
2961 end:
2962 msi_free(szwFilePath);
2963 msi_free(lpwVersionBuff);
2964 msi_free(lpwLangBuff);
2965
2966 return ret;
2967 }
2968
2969 /******************************************************************
2970 * MsiGetFileVersionW [MSI.@]
2971 */
2972 UINT WINAPI MsiGetFileVersionW(LPCWSTR szFilePath, LPWSTR lpVersionBuf,
2973 LPDWORD pcchVersionBuf, LPWSTR lpLangBuf, LPDWORD pcchLangBuf)
2974 {
2975 static const WCHAR szVersionResource[] = {'\\',0};
2976 static const WCHAR szVersionFormat[] = {
2977 '%','d','.','%','d','.','%','d','.','%','d',0};
2978 static const WCHAR szLangResource[] = {
2979 '\\','V','a','r','F','i','l','e','I','n','f','o','\\',
2980 'T','r','a','n','s','l','a','t','i','o','n',0};
2981 static const WCHAR szLangFormat[] = {'%','d',0};
2982 UINT ret = 0;
2983 DWORD dwVerLen, gle;
2984 LPVOID lpVer = NULL;
2985 VS_FIXEDFILEINFO *ffi;
2986 USHORT *lang;
2987 UINT puLen;
2988 WCHAR tmp[32];
2989
2990 TRACE("%s %p %d %p %d\n", debugstr_w(szFilePath),
2991 lpVersionBuf, pcchVersionBuf?*pcchVersionBuf:0,
2992 lpLangBuf, pcchLangBuf?*pcchLangBuf:0);
2993
2994 if ((lpVersionBuf && !pcchVersionBuf) ||
2995 (lpLangBuf && !pcchLangBuf))
2996 return ERROR_INVALID_PARAMETER;
2997
2998 dwVerLen = GetFileVersionInfoSizeW(szFilePath, NULL);
2999 if( !dwVerLen )
3000 {
3001 gle = GetLastError();
3002 if (gle == ERROR_BAD_PATHNAME)
3003 return ERROR_FILE_NOT_FOUND;
3004 else if (gle == ERROR_RESOURCE_DATA_NOT_FOUND)
3005 return ERROR_FILE_INVALID;
3006
3007 return gle;
3008 }
3009
3010 lpVer = msi_alloc(dwVerLen);
3011 if( !lpVer )
3012 {
3013 ret = ERROR_OUTOFMEMORY;
3014 goto end;
3015 }
3016
3017 if( !GetFileVersionInfoW(szFilePath, 0, dwVerLen, lpVer) )
3018 {
3019 ret = GetLastError();
3020 goto end;
3021 }
3022
3023 if (pcchVersionBuf)
3024 {
3025 if( VerQueryValueW(lpVer, szVersionResource, (LPVOID*)&ffi, &puLen) &&
3026 (puLen > 0) )
3027 {
3028 wsprintfW(tmp, szVersionFormat,
3029 HIWORD(ffi->dwFileVersionMS), LOWORD(ffi->dwFileVersionMS),
3030 HIWORD(ffi->dwFileVersionLS), LOWORD(ffi->dwFileVersionLS));
3031 if (lpVersionBuf) lstrcpynW(lpVersionBuf, tmp, *pcchVersionBuf);
3032
3033 if (strlenW(tmp) >= *pcchVersionBuf)
3034 ret = ERROR_MORE_DATA;
3035
3036 *pcchVersionBuf = lstrlenW(tmp);
3037 }
3038 else
3039 {
3040 if (lpVersionBuf) *lpVersionBuf = 0;
3041 *pcchVersionBuf = 0;
3042 }
3043 }
3044
3045 if (pcchLangBuf)
3046 {
3047 if (VerQueryValueW(lpVer, szLangResource, (LPVOID*)&lang, &puLen) &&
3048 (puLen > 0))
3049 {
3050 wsprintfW(tmp, szLangFormat, *lang);
3051 if (lpLangBuf) lstrcpynW(lpLangBuf, tmp, *pcchLangBuf);
3052
3053 if (strlenW(tmp) >= *pcchLangBuf)
3054 ret = ERROR_MORE_DATA;
3055
3056 *pcchLangBuf = lstrlenW(tmp);
3057 }
3058 else
3059 {
3060 if (lpLangBuf) *lpLangBuf = 0;
3061 *pcchLangBuf = 0;
3062 }
3063 }
3064
3065 end:
3066 msi_free(lpVer);
3067 return ret;
3068 }
3069
3070 /***********************************************************************
3071 * MsiGetFeatureUsageW [MSI.@]
3072 */
3073 UINT WINAPI MsiGetFeatureUsageW( LPCWSTR szProduct, LPCWSTR szFeature,
3074 LPDWORD pdwUseCount, LPWORD pwDateUsed )
3075 {
3076 FIXME("%s %s %p %p\n",debugstr_w(szProduct), debugstr_w(szFeature),
3077 pdwUseCount, pwDateUsed);
3078 return ERROR_CALL_NOT_IMPLEMENTED;
3079 }
3080
3081 /***********************************************************************
3082 * MsiGetFeatureUsageA [MSI.@]
3083 */
3084 UINT WINAPI MsiGetFeatureUsageA( LPCSTR szProduct, LPCSTR szFeature,
3085 LPDWORD pdwUseCount, LPWORD pwDateUsed )
3086 {
3087 LPWSTR prod = NULL, feat = NULL;
3088 UINT ret = ERROR_OUTOFMEMORY;
3089
3090 TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szFeature),
3091 pdwUseCount, pwDateUsed);
3092
3093 prod = strdupAtoW( szProduct );
3094 if (szProduct && !prod)
3095 goto end;
3096
3097 feat = strdupAtoW( szFeature );
3098 if (szFeature && !feat)
3099 goto end;
3100
3101 ret = MsiGetFeatureUsageW( prod, feat, pdwUseCount, pwDateUsed );
3102
3103 end:
3104 msi_free( prod );
3105 msi_free( feat );
3106
3107 return ret;
3108 }
3109
3110 /***********************************************************************
3111 * MsiUseFeatureExW [MSI.@]
3112 */
3113 INSTALLSTATE WINAPI MsiUseFeatureExW( LPCWSTR szProduct, LPCWSTR szFeature,
3114 DWORD dwInstallMode, DWORD dwReserved )
3115 {
3116 INSTALLSTATE state;
3117
3118 TRACE("%s %s %i %i\n", debugstr_w(szProduct), debugstr_w(szFeature),
3119 dwInstallMode, dwReserved);
3120
3121 state = MsiQueryFeatureStateW( szProduct, szFeature );
3122
3123 if (dwReserved)
3124 return INSTALLSTATE_INVALIDARG;
3125
3126 if (state == INSTALLSTATE_LOCAL && dwInstallMode != INSTALLMODE_NODETECTION)
3127 {
3128 FIXME("mark product %s feature %s as used\n",
3129 debugstr_w(szProduct), debugstr_w(szFeature) );
3130 }
3131
3132 return state;
3133 }
3134
3135 /***********************************************************************
3136 * MsiUseFeatureExA [MSI.@]
3137 */
3138 INSTALLSTATE WINAPI MsiUseFeatureExA( LPCSTR szProduct, LPCSTR szFeature,
3139 DWORD dwInstallMode, DWORD dwReserved )
3140 {
3141 INSTALLSTATE ret = INSTALLSTATE_UNKNOWN;
3142 LPWSTR prod = NULL, feat = NULL;
3143
3144 TRACE("%s %s %i %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
3145 dwInstallMode, dwReserved);
3146
3147 prod = strdupAtoW( szProduct );
3148 if (szProduct && !prod)
3149 goto end;
3150
3151 feat = strdupAtoW( szFeature );
3152 if (szFeature && !feat)
3153 goto end;
3154
3155 ret = MsiUseFeatureExW( prod, feat, dwInstallMode, dwReserved );
3156
3157 end:
3158 msi_free( prod );
3159 msi_free( feat );
3160
3161 return ret;
3162 }
3163
3164 /***********************************************************************
3165 * MsiUseFeatureW [MSI.@]
3166 */
3167 INSTALLSTATE WINAPI MsiUseFeatureW( LPCWSTR szProduct, LPCWSTR szFeature )
3168 {
3169 return MsiUseFeatureExW(szProduct, szFeature, 0, 0);
3170 }
3171
3172 /***********************************************************************
3173 * MsiUseFeatureA [MSI.@]
3174 */
3175 INSTALLSTATE WINAPI MsiUseFeatureA( LPCSTR szProduct, LPCSTR szFeature )
3176 {
3177 return MsiUseFeatureExA(szProduct, szFeature, 0, 0);
3178 }
3179
3180 /***********************************************************************
3181 * MSI_ProvideQualifiedComponentEx [internal]
3182 */
3183 static UINT MSI_ProvideQualifiedComponentEx(LPCWSTR szComponent,
3184 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
3185 DWORD Unused1, DWORD Unused2, awstring *lpPathBuf,
3186 LPDWORD pcchPathBuf)
3187 {
3188 WCHAR product[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1],
3189 feature[MAX_FEATURE_CHARS+1];
3190 LPWSTR info;
3191 HKEY hkey;
3192 DWORD sz;
3193 UINT rc;
3194
3195 TRACE("%s %s %i %s %i %i %p %p\n", debugstr_w(szComponent),
3196 debugstr_w(szQualifier), dwInstallMode, debugstr_w(szProduct),
3197 Unused1, Unused2, lpPathBuf, pcchPathBuf);
3198
3199 rc = MSIREG_OpenUserComponentsKey(szComponent, &hkey, FALSE);
3200 if (rc != ERROR_SUCCESS)
3201 return ERROR_INDEX_ABSENT;
3202
3203 info = msi_reg_get_val_str( hkey, szQualifier );
3204 RegCloseKey(hkey);
3205
3206 if (!info)
3207 return ERROR_INDEX_ABSENT;
3208
3209 MsiDecomposeDescriptorW(info, product, feature, component, &sz);
3210
3211 if (!szProduct)
3212 rc = MSI_GetComponentPath(product, component, lpPathBuf, pcchPathBuf);
3213 else
3214 rc = MSI_GetComponentPath(szProduct, component, lpPathBuf, pcchPathBuf);
3215
3216 msi_free( info );
3217
3218 if (rc != INSTALLSTATE_LOCAL)
3219 return ERROR_FILE_NOT_FOUND;
3220
3221 return ERROR_SUCCESS;
3222 }
3223
3224 /***********************************************************************
3225 * MsiProvideQualifiedComponentExW [MSI.@]
3226 */
3227 UINT WINAPI MsiProvideQualifiedComponentExW(LPCWSTR szComponent,
3228 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
3229 DWORD Unused1, DWORD Unused2, LPWSTR lpPathBuf,
3230 LPDWORD pcchPathBuf)
3231 {
3232 awstring path;
3233
3234 path.unicode = TRUE;
3235 path.str.w = lpPathBuf;
3236
3237 return MSI_ProvideQualifiedComponentEx(szComponent, szQualifier,
3238 dwInstallMode, szProduct, Unused1, Unused2, &path, pcchPathBuf);
3239 }
3240
3241 /***********************************************************************
3242 * MsiProvideQualifiedComponentExA [MSI.@]
3243 */
3244 UINT WINAPI MsiProvideQualifiedComponentExA(LPCSTR szComponent,
3245 LPCSTR szQualifier, DWORD dwInstallMode, LPCSTR szProduct,
3246 DWORD Unused1, DWORD Unused2, LPSTR lpPathBuf,
3247 LPDWORD pcchPathBuf)
3248 {
3249 LPWSTR szwComponent, szwQualifier = NULL, szwProduct = NULL;
3250 UINT r = ERROR_OUTOFMEMORY;
3251 awstring path;
3252
3253 TRACE("%s %s %u %s %u %u %p %p\n", debugstr_a(szComponent),
3254 debugstr_a(szQualifier), dwInstallMode, debugstr_a(szProduct),
3255 Unused1, Unused2, lpPathBuf, pcchPathBuf);
3256
3257 szwComponent = strdupAtoW( szComponent );
3258 if (szComponent && !szwComponent)
3259 goto end;
3260
3261 szwQualifier = strdupAtoW( szQualifier );
3262 if (szQualifier && !szwQualifier)
3263 goto end;
3264
3265 szwProduct = strdupAtoW( szProduct );
3266 if (szProduct && !szwProduct)
3267 goto end;
3268
3269 path.unicode = FALSE;
3270 path.str.a = lpPathBuf;
3271
3272 r = MSI_ProvideQualifiedComponentEx(szwComponent, szwQualifier,
3273 dwInstallMode, szwProduct, Unused1,
3274 Unused2, &path, pcchPathBuf);
3275 end:
3276 msi_free(szwProduct);
3277 msi_free(szwComponent);
3278 msi_free(szwQualifier);
3279
3280 return r;
3281 }
3282
3283 /***********************************************************************
3284 * MsiProvideQualifiedComponentW [MSI.@]
3285 */
3286 UINT WINAPI MsiProvideQualifiedComponentW( LPCWSTR szComponent,
3287 LPCWSTR szQualifier, DWORD dwInstallMode, LPWSTR lpPathBuf,
3288 LPDWORD pcchPathBuf)
3289 {
3290 return MsiProvideQualifiedComponentExW(szComponent, szQualifier,
3291 dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
3292 }
3293
3294 /***********************************************************************
3295 * MsiProvideQualifiedComponentA [MSI.@]
3296 */
3297 UINT WINAPI MsiProvideQualifiedComponentA( LPCSTR szComponent,
3298 LPCSTR szQualifier, DWORD dwInstallMode, LPSTR lpPathBuf,
3299 LPDWORD pcchPathBuf)
3300 {
3301 return MsiProvideQualifiedComponentExA(szComponent, szQualifier,
3302 dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
3303 }
3304
3305 /***********************************************************************
3306 * MSI_GetUserInfo [internal]
3307 */
3308 static USERINFOSTATE MSI_GetUserInfo(LPCWSTR szProduct,
3309 awstring *lpUserNameBuf, LPDWORD pcchUserNameBuf,
3310 awstring *lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
3311 awstring *lpSerialBuf, LPDWORD pcchSerialBuf)
3312 {
3313 WCHAR squished_pc[SQUISH_GUID_SIZE];
3314 LPWSTR user, org, serial;
3315 USERINFOSTATE state;
3316 HKEY hkey, props;
3317 LPCWSTR orgptr;
3318 UINT r;
3319
3320 TRACE("%s %p %p %p %p %p %p\n", debugstr_w(szProduct), lpUserNameBuf,
3321 pcchUserNameBuf, lpOrgNameBuf, pcchOrgNameBuf, lpSerialBuf,
3322 pcchSerialBuf);
3323
3324 if (!szProduct || !squash_guid(szProduct, squished_pc))
3325 return USERINFOSTATE_INVALIDARG;
3326
3327 if (MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
3328 &hkey, FALSE) != ERROR_SUCCESS &&
3329 MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3330 &hkey, FALSE) != ERROR_SUCCESS &&
3331 MSIREG_OpenProductKey(szProduct, NULL, MSIINSTALLCONTEXT_MACHINE,
3332 &hkey, FALSE) != ERROR_SUCCESS)
3333 {
3334 return USERINFOSTATE_UNKNOWN;
3335 }
3336
3337 if (MSIREG_OpenInstallProps(szProduct, MSIINSTALLCONTEXT_USERUNMANAGED,
3338 NULL, &props, FALSE) != ERROR_SUCCESS &&
3339 MSIREG_OpenInstallProps(szProduct, MSIINSTALLCONTEXT_MACHINE,
3340 NULL, &props, FALSE) != ERROR_SUCCESS)
3341 {
3342 RegCloseKey(hkey);
3343 return USERINFOSTATE_ABSENT;
3344 }
3345
3346 user = msi_reg_get_val_str(props, INSTALLPROPERTY_REGOWNERW);
3347 org = msi_reg_get_val_str(props, INSTALLPROPERTY_REGCOMPANYW);
3348 serial = msi_reg_get_val_str(props, INSTALLPROPERTY_PRODUCTIDW);
3349 state = USERINFOSTATE_ABSENT;
3350
3351 RegCloseKey(hkey);
3352 RegCloseKey(props);
3353
3354 if (user && serial)
3355 state = USERINFOSTATE_PRESENT;
3356
3357 if (pcchUserNameBuf)
3358 {
3359 if (lpUserNameBuf && !user)
3360 {
3361 (*pcchUserNameBuf)--;
3362 goto done;
3363 }
3364
3365 r = msi_strcpy_to_awstring(user, lpUserNameBuf, pcchUserNameBuf);
3366 if (r == ERROR_MORE_DATA)
3367 {
3368 state = USERINFOSTATE_MOREDATA;
3369 goto done;
3370 }
3371 }
3372
3373 if (pcchOrgNameBuf)
3374 {
3375 orgptr = org;
3376 if (!orgptr) orgptr = szEmpty;
3377
3378 r = msi_strcpy_to_awstring(orgptr, lpOrgNameBuf, pcchOrgNameBuf);
3379 if (r == ERROR_MORE_DATA)
3380 {
3381 state = USERINFOSTATE_MOREDATA;
3382 goto done;
3383 }
3384 }
3385
3386 if (pcchSerialBuf)
3387 {
3388 if (!serial)
3389 {
3390 (*pcchSerialBuf)--;
3391 goto done;
3392 }
3393
3394 r = msi_strcpy_to_awstring(serial, lpSerialBuf, pcchSerialBuf);
3395 if (r == ERROR_MORE_DATA)
3396 state = USERINFOSTATE_MOREDATA;
3397 }
3398
3399 done:
3400 msi_free(user);
3401 msi_free(org);
3402 msi_free(serial);
3403
3404 return state;
3405 }
3406
3407 /***********************************************************************
3408 * MsiGetUserInfoW [MSI.@]
3409 */
3410 USERINFOSTATE WINAPI MsiGetUserInfoW(LPCWSTR szProduct,
3411 LPWSTR lpUserNameBuf, LPDWORD pcchUserNameBuf,
3412 LPWSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
3413 LPWSTR lpSerialBuf, LPDWORD pcchSerialBuf)
3414 {
3415 awstring user, org, serial;
3416
3417 if ((lpUserNameBuf && !pcchUserNameBuf) ||
3418 (lpOrgNameBuf && !pcchOrgNameBuf) ||
3419 (lpSerialBuf && !pcchSerialBuf))
3420 return USERINFOSTATE_INVALIDARG;
3421
3422 user.unicode = TRUE;
3423 user.str.w = lpUserNameBuf;
3424 org.unicode = TRUE;
3425 org.str.w = lpOrgNameBuf;
3426 serial.unicode = TRUE;
3427 serial.str.w = lpSerialBuf;
3428
3429 return MSI_GetUserInfo( szProduct, &user, pcchUserNameBuf,
3430 &org, pcchOrgNameBuf,
3431 &serial, pcchSerialBuf );
3432 }
3433
3434 USERINFOSTATE WINAPI MsiGetUserInfoA(LPCSTR szProduct,
3435 LPSTR lpUserNameBuf, LPDWORD pcchUserNameBuf,
3436 LPSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
3437 LPSTR lpSerialBuf, LPDWORD pcchSerialBuf)
3438 {
3439 awstring user, org, serial;
3440 LPWSTR prod;
3441 UINT r;
3442
3443 if ((lpUserNameBuf && !pcchUserNameBuf) ||
3444 (lpOrgNameBuf && !pcchOrgNameBuf) ||
3445 (lpSerialBuf && !pcchSerialBuf))
3446 return USERINFOSTATE_INVALIDARG;
3447
3448 prod = strdupAtoW( szProduct );
3449 if (szProduct && !prod)
3450 return ERROR_OUTOFMEMORY;
3451
3452 user.unicode = FALSE;
3453 user.str.a = lpUserNameBuf;
3454 org.unicode = FALSE;
3455 org.str.a = lpOrgNameBuf;
3456 serial.unicode = FALSE;
3457 serial.str.a = lpSerialBuf;
3458
3459 r = MSI_GetUserInfo( prod, &user, pcchUserNameBuf,
3460 &org, pcchOrgNameBuf,
3461 &serial, pcchSerialBuf );
3462
3463 msi_free( prod );
3464
3465 return r;
3466 }
3467
3468 UINT WINAPI MsiCollectUserInfoW(LPCWSTR szProduct)
3469 {
3470 MSIHANDLE handle;
3471 UINT rc;
3472 MSIPACKAGE *package;
3473 static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
3474
3475 TRACE("(%s)\n",debugstr_w(szProduct));
3476
3477 rc = MsiOpenProductW(szProduct,&handle);
3478 if (rc != ERROR_SUCCESS)
3479 return ERROR_INVALID_PARAMETER;
3480
3481 /* MsiCollectUserInfo cannot be called from a custom action. */
3482 package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
3483 if (!package)
3484 return ERROR_CALL_NOT_IMPLEMENTED;
3485
3486 rc = ACTION_PerformUIAction(package, szFirstRun, -1);
3487 msiobj_release( &package->hdr );
3488
3489 MsiCloseHandle(handle);
3490
3491 return rc;
3492 }
3493
3494 UINT WINAPI MsiCollectUserInfoA(LPCSTR szProduct)
3495 {
3496 MSIHANDLE handle;
3497 UINT rc;
3498 MSIPACKAGE *package;
3499 static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
3500
3501 TRACE("(%s)\n",debugstr_a(szProduct));
3502
3503 rc = MsiOpenProductA(szProduct,&handle);
3504 if (rc != ERROR_SUCCESS)
3505 return ERROR_INVALID_PARAMETER;
3506
3507 /* MsiCollectUserInfo cannot be called from a custom action. */
3508 package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
3509 if (!package)
3510 return ERROR_CALL_NOT_IMPLEMENTED;
3511
3512 rc = ACTION_PerformUIAction(package, szFirstRun, -1);
3513 msiobj_release( &package->hdr );
3514
3515 MsiCloseHandle(handle);
3516
3517 return rc;
3518 }
3519
3520 /***********************************************************************
3521 * MsiConfigureFeatureA [MSI.@]
3522 */
3523 UINT WINAPI MsiConfigureFeatureA(LPCSTR szProduct, LPCSTR szFeature, INSTALLSTATE eInstallState)
3524 {
3525 LPWSTR prod, feat = NULL;
3526 UINT r = ERROR_OUTOFMEMORY;
3527
3528 TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature), eInstallState);
3529
3530 prod = strdupAtoW( szProduct );
3531 if (szProduct && !prod)
3532 goto end;
3533
3534 feat = strdupAtoW( szFeature );
3535 if (szFeature && !feat)
3536 goto end;
3537
3538 r = MsiConfigureFeatureW(prod, feat, eInstallState);
3539
3540 end:
3541 msi_free(feat);
3542 msi_free(prod);
3543
3544 return r;
3545 }
3546
3547 /***********************************************************************
3548 * MsiConfigureFeatureW [MSI.@]
3549 */
3550 UINT WINAPI MsiConfigureFeatureW(LPCWSTR szProduct, LPCWSTR szFeature, INSTALLSTATE eInstallState)
3551 {
3552 MSIPACKAGE *package = NULL;
3553 UINT r;
3554 WCHAR sourcepath[MAX_PATH], filename[MAX_PATH];
3555 DWORD sz;
3556
3557 TRACE("%s %s %i\n", debugstr_w(szProduct), debugstr_w(szFeature), eInstallState);
3558
3559 if (!szProduct || !szFeature)
3560 return ERROR_INVALID_PARAMETER;
3561
3562 switch (eInstallState)
3563 {
3564 case INSTALLSTATE_DEFAULT:
3565 /* FIXME: how do we figure out the default location? */
3566 eInstallState = INSTALLSTATE_LOCAL;
3567 break;
3568 case INSTALLSTATE_LOCAL:
3569 case INSTALLSTATE_SOURCE:
3570 case INSTALLSTATE_ABSENT:
3571 case INSTALLSTATE_ADVERTISED:
3572 break;
3573 default:
3574 return ERROR_INVALID_PARAMETER;
3575 }
3576
3577 r = MSI_OpenProductW( szProduct, &package );
3578 if (r != ERROR_SUCCESS)
3579 return r;
3580
3581 sz = sizeof(sourcepath);
3582 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3583 MSICODE_PRODUCT, INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
3584
3585 sz = sizeof(filename);
3586 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3587 MSICODE_PRODUCT, INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
3588
3589 lstrcatW( sourcepath, filename );
3590
3591 MsiSetInternalUI( INSTALLUILEVEL_BASIC, NULL );
3592
3593 r = ACTION_PerformUIAction( package, szCostInitialize, -1 );
3594 if (r != ERROR_SUCCESS)
3595 goto end;
3596
3597 r = MSI_SetFeatureStateW( package, szFeature, eInstallState);
3598 if (r != ERROR_SUCCESS)
3599 goto end;
3600
3601 r = MSI_InstallPackage( package, sourcepath, NULL );
3602
3603 end:
3604 msiobj_release( &package->hdr );
3605
3606 return r;
3607 }
3608
3609 /***********************************************************************
3610 * MsiCreateAndVerifyInstallerDirectory [MSI.@]
3611 *
3612 * Notes: undocumented
3613 */
3614 UINT WINAPI MsiCreateAndVerifyInstallerDirectory(DWORD dwReserved)
3615 {
3616 WCHAR path[MAX_PATH];
3617
3618 TRACE("%d\n", dwReserved);
3619
3620 if (dwReserved)
3621 {
3622 FIXME("dwReserved=%d\n", dwReserved);
3623 return ERROR_INVALID_PARAMETER;
3624 }
3625
3626 if (!GetWindowsDirectoryW(path, MAX_PATH))
3627 return ERROR_FUNCTION_FAILED;
3628
3629 lstrcatW(path, installerW);
3630
3631 if (!CreateDirectoryW(path, NULL))
3632 return ERROR_FUNCTION_FAILED;
3633
3634 return ERROR_SUCCESS;
3635 }
3636
3637 /***********************************************************************
3638 * MsiGetShortcutTargetA [MSI.@]
3639 */
3640 UINT WINAPI MsiGetShortcutTargetA( LPCSTR szShortcutTarget,
3641 LPSTR szProductCode, LPSTR szFeatureId,
3642 LPSTR szComponentCode )
3643 {
3644 LPWSTR target;
3645 const int len = MAX_FEATURE_CHARS+1;
3646 WCHAR product[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1];
3647 UINT r;
3648
3649 target = strdupAtoW( szShortcutTarget );
3650 if (szShortcutTarget && !target )
3651 return ERROR_OUTOFMEMORY;
3652 product[0] = 0;
3653 feature[0] = 0;
3654 component[0] = 0;
3655 r = MsiGetShortcutTargetW( target, product, feature, component );
3656 msi_free( target );
3657 if (r == ERROR_SUCCESS)
3658 {
3659 WideCharToMultiByte( CP_ACP, 0, product, -1, szProductCode, len, NULL, NULL );
3660 WideCharToMultiByte( CP_ACP, 0, feature, -1, szFeatureId, len, NULL, NULL );
3661 WideCharToMultiByte( CP_ACP, 0, component, -1, szComponentCode, len, NULL, NULL );
3662 }
3663 return r;
3664 }
3665
3666 /***********************************************************************
3667 * MsiGetShortcutTargetW [MSI.@]
3668 */
3669 UINT WINAPI MsiGetShortcutTargetW( LPCWSTR szShortcutTarget,
3670 LPWSTR szProductCode, LPWSTR szFeatureId,
3671 LPWSTR szComponentCode )
3672 {
3673 IShellLinkDataList *dl = NULL;
3674 IPersistFile *pf = NULL;
3675 LPEXP_DARWIN_LINK darwin = NULL;
3676 HRESULT r, init;
3677
3678 TRACE("%s %p %p %p\n", debugstr_w(szShortcutTarget),
3679 szProductCode, szFeatureId, szComponentCode );
3680
3681 init = CoInitialize(NULL);
3682
3683 r = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3684 &IID_IPersistFile, (LPVOID*) &pf );
3685 if( SUCCEEDED( r ) )
3686 {
3687 r = IPersistFile_Load( pf, szShortcutTarget,
3688 STGM_READ | STGM_SHARE_DENY_WRITE );
3689 if( SUCCEEDED( r ) )
3690 {
3691 r = IPersistFile_QueryInterface( pf, &IID_IShellLinkDataList,
3692 (LPVOID*) &dl );
3693 if( SUCCEEDED( r ) )
3694 {
3695 IShellLinkDataList_CopyDataBlock( dl, EXP_DARWIN_ID_SIG,
3696 (LPVOID) &darwin );
3697 IShellLinkDataList_Release( dl );
3698 }
3699 }
3700 IPersistFile_Release( pf );
3701 }
3702
3703 if (SUCCEEDED(init))
3704 CoUninitialize();
3705
3706 TRACE("darwin = %p\n", darwin);
3707
3708 if (darwin)
3709 {
3710 DWORD sz;
3711 UINT ret;
3712
3713 ret = MsiDecomposeDescriptorW( darwin->szwDarwinID,
3714 szProductCode, szFeatureId, szComponentCode, &sz );
3715 LocalFree( darwin );
3716 return ret;
3717 }
3718
3719 return ERROR_FUNCTION_FAILED;
3720 }
3721
3722 UINT WINAPI MsiReinstallFeatureW( LPCWSTR szProduct, LPCWSTR szFeature,
3723 DWORD dwReinstallMode )
3724 {
3725 MSIPACKAGE* package = NULL;
3726 UINT r;
3727 WCHAR sourcepath[MAX_PATH];
3728 WCHAR filename[MAX_PATH];
3729 static const WCHAR szLogVerbose[] = {
3730 ' ','L','O','G','V','E','R','B','O','S','E',0 };
3731 WCHAR reinstallmode[11];
3732 LPWSTR ptr;
3733 DWORD sz;
3734
3735 FIXME("%s %s 0x%08x\n",
3736 debugstr_w(szProduct), debugstr_w(szFeature), dwReinstallMode);
3737
3738 ptr = reinstallmode;
3739
3740 if (dwReinstallMode & REINSTALLMODE_FILEMISSING)
3741 *ptr++ = 'p';
3742 if (dwReinstallMode & REINSTALLMODE_FILEOLDERVERSION)
3743 *ptr++ = 'o';
3744 if (dwReinstallMode & REINSTALLMODE_FILEEQUALVERSION)
3745 *ptr++ = 'w';
3746 if (dwReinstallMode & REINSTALLMODE_FILEEXACT)
3747 *ptr++ = 'd';
3748 if (dwReinstallMode & REINSTALLMODE_FILEVERIFY)
3749 *ptr++ = 'c';
3750 if (dwReinstallMode & REINSTALLMODE_FILEREPLACE)
3751 *ptr++ = 'a';
3752 if (dwReinstallMode & REINSTALLMODE_USERDATA)
3753 *ptr++ = 'u';
3754 if (dwReinstallMode & REINSTALLMODE_MACHINEDATA)
3755 *ptr++ = 'm';
3756 if (dwReinstallMode & REINSTALLMODE_SHORTCUT)
3757 *ptr++ = 's';
3758 if (dwReinstallMode & REINSTALLMODE_PACKAGE)
3759 *ptr++ = 'v';
3760 *ptr = 0;
3761
3762 sz = sizeof(sourcepath);
3763 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3764 MSICODE_PRODUCT, INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
3765
3766 sz = sizeof(filename);
3767 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
3768 MSICODE_PRODUCT, INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
3769
3770 lstrcatW( sourcepath, filename );
3771
3772 if (dwReinstallMode & REINSTALLMODE_PACKAGE)
3773 r = MSI_OpenPackageW( sourcepath, &package );
3774 else
3775 r = MSI_OpenProductW( szProduct, &package );
3776
3777 if (r != ERROR_SUCCESS)
3778 return r;
3779
3780 msi_set_property( package->db, szReinstallMode, reinstallmode );
3781 msi_set_property( package->db, szInstalled, szOne );
3782 msi_set_property( package->db, szLogVerbose, szOne );
3783 msi_set_property( package->db, szReinstall, szFeature );
3784
3785 r = MSI_InstallPackage( package, sourcepath, NULL );
3786
3787 msiobj_release( &package->hdr );
3788
3789 return r;
3790 }
3791
3792 UINT WINAPI MsiReinstallFeatureA( LPCSTR szProduct, LPCSTR szFeature,
3793 DWORD dwReinstallMode )
3794 {
3795 LPWSTR wszProduct;
3796 LPWSTR wszFeature;
3797 UINT rc;
3798
3799 TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
3800 dwReinstallMode);
3801
3802 wszProduct = strdupAtoW(szProduct);
3803 wszFeature = strdupAtoW(szFeature);
3804
3805 rc = MsiReinstallFeatureW(wszProduct, wszFeature, dwReinstallMode);
3806
3807 msi_free(wszProduct);
3808 msi_free(wszFeature);
3809 return rc;
3810 }
3811
3812 typedef struct
3813 {
3814 unsigned int i[2];
3815 unsigned int buf[4];
3816 unsigned char in[64];
3817 unsigned char digest[16];
3818 } MD5_CTX;
3819
3820 extern VOID WINAPI MD5Init( MD5_CTX *);
3821 extern VOID WINAPI MD5Update( MD5_CTX *, const unsigned char *, unsigned int );
3822 extern VOID WINAPI MD5Final( MD5_CTX *);
3823
3824 /***********************************************************************
3825 * MsiGetFileHashW [MSI.@]
3826 */
3827 UINT WINAPI MsiGetFileHashW( LPCWSTR szFilePath, DWORD dwOptions,
3828 PMSIFILEHASHINFO pHash )
3829 {
3830 HANDLE handle, mapping;
3831 void *p;
3832 DWORD length;
3833 UINT r = ERROR_FUNCTION_FAILED;
3834
3835 TRACE("%s %08x %p\n", debugstr_w(szFilePath), dwOptions, pHash );
3836
3837 if (!szFilePath)
3838 return ERROR_INVALID_PARAMETER;
3839
3840 if (!*szFilePath)
3841 return ERROR_PATH_NOT_FOUND;
3842
3843 if (dwOptions)
3844 return ERROR_INVALID_PARAMETER;
3845 if (!pHash)
3846 return ERROR_INVALID_PARAMETER;
3847 if (pHash->dwFileHashInfoSize < sizeof *pHash)
3848 return ERROR_INVALID_PARAMETER;
3849
3850 handle = CreateFileW( szFilePath, GENERIC_READ,
3851 FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, NULL );
3852 if (handle == INVALID_HANDLE_VALUE)
3853 {
3854 WARN("can't open file %u\n", GetLastError());
3855 return ERROR_FILE_NOT_FOUND;
3856 }
3857 length = GetFileSize( handle, NULL );
3858
3859 mapping = CreateFileMappingW( handle, NULL, PAGE_READONLY, 0, 0, NULL );
3860 if (mapping)
3861 {
3862 p = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, length );
3863 if (p)
3864 {
3865 MD5_CTX ctx;
3866
3867 MD5Init( &ctx );
3868 MD5Update( &ctx, p, length );
3869 MD5Final( &ctx );
3870 UnmapViewOfFile( p );
3871
3872 memcpy( pHash->dwData, ctx.digest, sizeof pHash->dwData );
3873 r = ERROR_SUCCESS;
3874 }
3875 CloseHandle( mapping );
3876 }
3877 CloseHandle( handle );
3878
3879 return r;
3880 }
3881
3882 /***********************************************************************
3883 * MsiGetFileHashA [MSI.@]
3884 */
3885 UINT WINAPI MsiGetFileHashA( LPCSTR szFilePath, DWORD dwOptions,
3886 PMSIFILEHASHINFO pHash )
3887 {
3888 LPWSTR file;
3889 UINT r;
3890
3891 TRACE("%s %08x %p\n", debugstr_a(szFilePath), dwOptions, pHash );
3892
3893 file = strdupAtoW( szFilePath );
3894 if (szFilePath && !file)
3895 return ERROR_OUTOFMEMORY;
3896
3897 r = MsiGetFileHashW( file, dwOptions, pHash );
3898 msi_free( file );
3899 return r;
3900 }
3901
3902 /***********************************************************************
3903 * MsiAdvertiseScriptW [MSI.@]
3904 */
3905 UINT WINAPI MsiAdvertiseScriptW( LPCWSTR szScriptFile, DWORD dwFlags,
3906 PHKEY phRegData, BOOL fRemoveItems )
3907 {
3908 FIXME("%s %08x %p %d\n",
3909 debugstr_w( szScriptFile ), dwFlags, phRegData, fRemoveItems );
3910 return ERROR_CALL_NOT_IMPLEMENTED;
3911 }
3912
3913 /***********************************************************************
3914 * MsiAdvertiseScriptA [MSI.@]
3915 */
3916 UINT WINAPI MsiAdvertiseScriptA( LPCSTR szScriptFile, DWORD dwFlags,
3917 PHKEY phRegData, BOOL fRemoveItems )
3918 {
3919 FIXME("%s %08x %p %d\n",
3920 debugstr_a( szScriptFile ), dwFlags, phRegData, fRemoveItems );
3921 return ERROR_CALL_NOT_IMPLEMENTED;
3922 }
3923
3924 /***********************************************************************
3925 * MsiIsProductElevatedW [MSI.@]
3926 */
3927 UINT WINAPI MsiIsProductElevatedW( LPCWSTR szProduct, BOOL *pfElevated )
3928 {
3929 FIXME("%s %p - stub\n",
3930 debugstr_w( szProduct ), pfElevated );
3931 *pfElevated = TRUE;
3932 return ERROR_SUCCESS;
3933 }
3934
3935 /***********************************************************************
3936 * MsiIsProductElevatedA [MSI.@]
3937 */
3938 UINT WINAPI MsiIsProductElevatedA( LPCSTR szProduct, BOOL *pfElevated )
3939 {
3940 FIXME("%s %p - stub\n",
3941 debugstr_a( szProduct ), pfElevated );
3942 *pfElevated = TRUE;
3943 return ERROR_SUCCESS;
3944 }
3945
3946 /***********************************************************************
3947 * MsiSetExternalUIRecord [MSI.@]
3948 */
3949 UINT WINAPI MsiSetExternalUIRecord( INSTALLUI_HANDLER_RECORD handler,
3950 DWORD filter, LPVOID context,
3951 PINSTALLUI_HANDLER_RECORD prev )
3952 {
3953 TRACE("%p %08x %p %p\n", handler, filter, context, prev);
3954
3955 if (prev)
3956 *prev = gUIHandlerRecord;
3957
3958 gUIHandlerRecord = handler;
3959 gUIFilter = filter;
3960 gUIContext = context;
3961
3962 return ERROR_SUCCESS;
3963 }
3964
3965 /***********************************************************************
3966 * MsiInstallMissingComponentA [MSI.@]
3967 */
3968 UINT WINAPI MsiInstallMissingComponentA( LPCSTR product, LPCSTR component, INSTALLSTATE state )
3969 {
3970 UINT r;
3971 WCHAR *productW = NULL, *componentW = NULL;
3972
3973 TRACE("%s, %s, %d\n", debugstr_a(product), debugstr_a(component), state);
3974
3975 if (product && !(productW = strdupAtoW( product )))
3976 return ERROR_OUTOFMEMORY;
3977
3978 if (component && !(componentW = strdupAtoW( component )))
3979 {
3980 msi_free( productW );
3981 return ERROR_OUTOFMEMORY;
3982 }
3983
3984 r = MsiInstallMissingComponentW( productW, componentW, state );
3985 msi_free( productW );
3986 msi_free( componentW );
3987 return r;
3988 }
3989
3990 /***********************************************************************
3991 * MsiInstallMissingComponentW [MSI.@]
3992 */
3993 UINT WINAPI MsiInstallMissingComponentW(LPCWSTR szProduct, LPCWSTR szComponent, INSTALLSTATE eInstallState)
3994 {
3995 FIXME("(%s %s %d\n", debugstr_w(szProduct), debugstr_w(szComponent), eInstallState);
3996 return ERROR_SUCCESS;
3997 }
3998
3999 /***********************************************************************
4000 * MsiBeginTransactionA [MSI.@]
4001 */
4002 UINT WINAPI MsiBeginTransactionA( LPCSTR name, DWORD attrs, MSIHANDLE *id, HANDLE *event )
4003 {
4004 WCHAR *nameW;
4005 UINT r;
4006
4007 FIXME("%s %u %p %p\n", debugstr_a(name), attrs, id, event);
4008
4009 nameW = strdupAtoW( name );
4010 if (name && !nameW)
4011 return ERROR_OUTOFMEMORY;
4012
4013 r = MsiBeginTransactionW( nameW, attrs, id, event );
4014 msi_free( nameW );
4015 return r;
4016 }
4017
4018 /***********************************************************************
4019 * MsiBeginTransactionW [MSI.@]
4020 */
4021 UINT WINAPI MsiBeginTransactionW( LPCWSTR name, DWORD attrs, MSIHANDLE *id, HANDLE *event )
4022 {
4023 FIXME("%s %u %p %p\n", debugstr_w(name), attrs, id, event);
4024
4025 *id = (MSIHANDLE)0xdeadbeef;
4026 *event = (HANDLE)0xdeadbeef;
4027
4028 return ERROR_SUCCESS;
4029 }
4030
4031 /***********************************************************************
4032 * MsiEndTransaction [MSI.@]
4033 */
4034 UINT WINAPI MsiEndTransaction( DWORD state )
4035 {
4036 FIXME("%u\n", state);
4037 return ERROR_SUCCESS;
4038 }
Maarten's multimedia branch