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