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