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