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