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