?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dplayx: Tests for checking the behaviour of groups in a p2p session.
[wine/gsoc_dplay.git] / dlls / msi / msi.c
blob9055c599a7962a5d727c696937d8e7b65b4a1d9d
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, 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 *sz = 0;
1317 res = RegQueryValueExW(hkey, squished_pc, NULL, NULL, NULL, sz);
1318 if (res != ERROR_SUCCESS)
1319 return FALSE;
1320
1321 RegCloseKey(hkey);
1322 return TRUE;
1323 }
1324
1325 UINT WINAPI MsiQueryComponentStateW(LPCWSTR szProductCode,
1326 LPCWSTR szUserSid, MSIINSTALLCONTEXT dwContext,
1327 LPCWSTR szComponent, INSTALLSTATE *pdwState)
1328 {
1329 WCHAR squished_pc[GUID_SIZE];
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 if (!msi_comp_find_prodcode(squished_pc, dwContext, szComponent, &sz))
1361 return ERROR_UNKNOWN_COMPONENT;
1362
1363 if (sz == 0)
1364 *pdwState = INSTALLSTATE_NOTUSED;
1365 else
1366 *pdwState = INSTALLSTATE_LOCAL;
1367
1368 return ERROR_SUCCESS;
1369 }
1370
1371 INSTALLSTATE WINAPI MsiQueryProductStateA(LPCSTR szProduct)
1372 {
1373 LPWSTR szwProduct = NULL;
1374 INSTALLSTATE r;
1375
1376 if( szProduct )
1377 {
1378 szwProduct = strdupAtoW( szProduct );
1379 if( !szwProduct )
1380 return ERROR_OUTOFMEMORY;
1381 }
1382 r = MsiQueryProductStateW( szwProduct );
1383 msi_free( szwProduct );
1384 return r;
1385 }
1386
1387 INSTALLSTATE WINAPI MsiQueryProductStateW(LPCWSTR szProduct)
1388 {
1389 INSTALLSTATE state = INSTALLSTATE_ADVERTISED;
1390 HKEY prodkey = 0, userdata = 0;
1391 BOOL user = TRUE;
1392 DWORD val;
1393 UINT r;
1394
1395 static const WCHAR szWindowsInstaller[] = {
1396 'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
1397
1398 TRACE("%s\n", debugstr_w(szProduct));
1399
1400 if (!szProduct || !*szProduct)
1401 return INSTALLSTATE_INVALIDARG;
1402
1403 if (lstrlenW(szProduct) != GUID_SIZE - 1)
1404 return INSTALLSTATE_INVALIDARG;
1405
1406 r = MSIREG_OpenLocalManagedProductKey(szProduct, &prodkey, FALSE);
1407 if (r != ERROR_SUCCESS)
1408 {
1409 r = MSIREG_OpenUserProductsKey(szProduct, &prodkey, FALSE);
1410 if (r != ERROR_SUCCESS)
1411 {
1412 r = MSIREG_OpenLocalClassesProductKey(szProduct, &prodkey, FALSE);
1413 if (r == ERROR_SUCCESS)
1414 user = FALSE;
1415 }
1416 }
1417
1418 if (user)
1419 {
1420 r = MSIREG_OpenCurrentUserInstallProps(szProduct, &userdata, FALSE);
1421 if (r != ERROR_SUCCESS)
1422 goto done;
1423 }
1424 else
1425 {
1426 r = MSIREG_OpenLocalSystemInstallProps(szProduct, &userdata, FALSE);
1427 if (r != ERROR_SUCCESS)
1428 goto done;
1429 }
1430
1431 if (!msi_reg_get_val_dword(userdata, szWindowsInstaller, &val))
1432 goto done;
1433
1434 if (val)
1435 state = INSTALLSTATE_DEFAULT;
1436 else
1437 state = INSTALLSTATE_UNKNOWN;
1438
1439 done:
1440 if (!prodkey)
1441 {
1442 state = INSTALLSTATE_UNKNOWN;
1443
1444 if (userdata)
1445 state = INSTALLSTATE_ABSENT;
1446 }
1447
1448 RegCloseKey(prodkey);
1449 RegCloseKey(userdata);
1450 return state;
1451 }
1452
1453 INSTALLUILEVEL WINAPI MsiSetInternalUI(INSTALLUILEVEL dwUILevel, HWND *phWnd)
1454 {
1455 INSTALLUILEVEL old = gUILevel;
1456 HWND oldwnd = gUIhwnd;
1457
1458 TRACE("%08x %p\n", dwUILevel, phWnd);
1459
1460 gUILevel = dwUILevel;
1461 if (phWnd)
1462 {
1463 gUIhwnd = *phWnd;
1464 *phWnd = oldwnd;
1465 }
1466 return old;
1467 }
1468
1469 INSTALLUI_HANDLERA WINAPI MsiSetExternalUIA(INSTALLUI_HANDLERA puiHandler,
1470 DWORD dwMessageFilter, LPVOID pvContext)
1471 {
1472 INSTALLUI_HANDLERA prev = gUIHandlerA;
1473
1474 TRACE("%p %x %p\n",puiHandler, dwMessageFilter,pvContext);
1475 gUIHandlerA = puiHandler;
1476 gUIFilter = dwMessageFilter;
1477 gUIContext = pvContext;
1478
1479 return prev;
1480 }
1481
1482 INSTALLUI_HANDLERW WINAPI MsiSetExternalUIW(INSTALLUI_HANDLERW puiHandler,
1483 DWORD dwMessageFilter, LPVOID pvContext)
1484 {
1485 INSTALLUI_HANDLERW prev = gUIHandlerW;
1486
1487 TRACE("%p %x %p\n",puiHandler,dwMessageFilter,pvContext);
1488 gUIHandlerW = puiHandler;
1489 gUIFilter = dwMessageFilter;
1490 gUIContext = pvContext;
1491
1492 return prev;
1493 }
1494
1495 /******************************************************************
1496 * MsiLoadStringW [MSI.@]
1497 *
1498 * Loads a string from MSI's string resources.
1499 *
1500 * PARAMS
1501 *
1502 * handle [I] only -1 is handled currently
1503 * id [I] id of the string to be loaded
1504 * lpBuffer [O] buffer for the string to be written to
1505 * nBufferMax [I] maximum size of the buffer in characters
1506 * lang [I] the preferred language for the string
1507 *
1508 * RETURNS
1509 *
1510 * If successful, this function returns the language id of the string loaded
1511 * If the function fails, the function returns zero.
1512 *
1513 * NOTES
1514 *
1515 * The type of the first parameter is unknown. LoadString's prototype
1516 * suggests that it might be a module handle. I have made it an MSI handle
1517 * for starters, as -1 is an invalid MSI handle, but not an invalid module
1518 * handle. Maybe strings can be stored in an MSI database somehow.
1519 */
1520 LANGID WINAPI MsiLoadStringW( MSIHANDLE handle, UINT id, LPWSTR lpBuffer,
1521 int nBufferMax, LANGID lang )
1522 {
1523 HRSRC hres;
1524 HGLOBAL hResData;
1525 LPWSTR p;
1526 DWORD i, len;
1527
1528 TRACE("%ld %u %p %d %d\n", handle, id, lpBuffer, nBufferMax, lang);
1529
1530 if( handle != -1 )
1531 FIXME("don't know how to deal with handle = %08lx\n", handle);
1532
1533 if( !lang )
1534 lang = GetUserDefaultLangID();
1535
1536 hres = FindResourceExW( msi_hInstance, (LPCWSTR) RT_STRING,
1537 (LPWSTR)1, lang );
1538 if( !hres )
1539 return 0;
1540 hResData = LoadResource( msi_hInstance, hres );
1541 if( !hResData )
1542 return 0;
1543 p = LockResource( hResData );
1544 if( !p )
1545 return 0;
1546
1547 for (i = 0; i < (id&0xf); i++)
1548 p += *p + 1;
1549 len = *p;
1550
1551 if( nBufferMax <= len )
1552 return 0;
1553
1554 memcpy( lpBuffer, p+1, len * sizeof(WCHAR));
1555 lpBuffer[ len ] = 0;
1556
1557 TRACE("found -> %s\n", debugstr_w(lpBuffer));
1558
1559 return lang;
1560 }
1561
1562 LANGID WINAPI MsiLoadStringA( MSIHANDLE handle, UINT id, LPSTR lpBuffer,
1563 int nBufferMax, LANGID lang )
1564 {
1565 LPWSTR bufW;
1566 LANGID r;
1567 DWORD len;
1568
1569 bufW = msi_alloc(nBufferMax*sizeof(WCHAR));
1570 r = MsiLoadStringW(handle, id, bufW, nBufferMax, lang);
1571 if( r )
1572 {
1573 len = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL, NULL );
1574 if( len <= nBufferMax )
1575 WideCharToMultiByte( CP_ACP, 0, bufW, -1,
1576 lpBuffer, nBufferMax, NULL, NULL );
1577 else
1578 r = 0;
1579 }
1580 msi_free(bufW);
1581 return r;
1582 }
1583
1584 INSTALLSTATE WINAPI MsiLocateComponentA(LPCSTR szComponent, LPSTR lpPathBuf,
1585 LPDWORD pcchBuf)
1586 {
1587 char szProduct[GUID_SIZE];
1588
1589 TRACE("%s %p %p\n", debugstr_a(szComponent), lpPathBuf, pcchBuf);
1590
1591 if (MsiGetProductCodeA( szComponent, szProduct ) != ERROR_SUCCESS)
1592 return INSTALLSTATE_UNKNOWN;
1593
1594 return MsiGetComponentPathA( szProduct, szComponent, lpPathBuf, pcchBuf );
1595 }
1596
1597 INSTALLSTATE WINAPI MsiLocateComponentW(LPCWSTR szComponent, LPWSTR lpPathBuf,
1598 LPDWORD pcchBuf)
1599 {
1600 WCHAR szProduct[GUID_SIZE];
1601
1602 TRACE("%s %p %p\n", debugstr_w(szComponent), lpPathBuf, pcchBuf);
1603
1604 if (MsiGetProductCodeW( szComponent, szProduct ) != ERROR_SUCCESS)
1605 return INSTALLSTATE_UNKNOWN;
1606
1607 return MsiGetComponentPathW( szProduct, szComponent, lpPathBuf, pcchBuf );
1608 }
1609
1610 UINT WINAPI MsiMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,
1611 WORD wLanguageId, DWORD f)
1612 {
1613 FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_a(lpText), debugstr_a(lpCaption),
1614 uType, wLanguageId, f);
1615 return MessageBoxExA(hWnd,lpText,lpCaption,uType,wLanguageId);
1616 }
1617
1618 UINT WINAPI MsiMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,
1619 WORD wLanguageId, DWORD f)
1620 {
1621 FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_w(lpText), debugstr_w(lpCaption),
1622 uType, wLanguageId, f);
1623 return MessageBoxExW(hWnd,lpText,lpCaption,uType,wLanguageId);
1624 }
1625
1626 UINT WINAPI MsiProvideAssemblyA( LPCSTR szAssemblyName, LPCSTR szAppContext,
1627 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPSTR lpPathBuf,
1628 LPDWORD pcchPathBuf )
1629 {
1630 FIXME("%s %s %08x %08x %p %p\n", debugstr_a(szAssemblyName),
1631 debugstr_a(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
1632 pcchPathBuf);
1633 return ERROR_CALL_NOT_IMPLEMENTED;
1634 }
1635
1636 UINT WINAPI MsiProvideAssemblyW( LPCWSTR szAssemblyName, LPCWSTR szAppContext,
1637 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPWSTR lpPathBuf,
1638 LPDWORD pcchPathBuf )
1639 {
1640 FIXME("%s %s %08x %08x %p %p\n", debugstr_w(szAssemblyName),
1641 debugstr_w(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
1642 pcchPathBuf);
1643 return ERROR_CALL_NOT_IMPLEMENTED;
1644 }
1645
1646 UINT WINAPI MsiProvideComponentFromDescriptorA( LPCSTR szDescriptor,
1647 LPSTR szPath, LPDWORD pcchPath, LPDWORD pcchArgs )
1648 {
1649 FIXME("%s %p %p %p\n", debugstr_a(szDescriptor), szPath, pcchPath, pcchArgs );
1650 return ERROR_CALL_NOT_IMPLEMENTED;
1651 }
1652
1653 UINT WINAPI MsiProvideComponentFromDescriptorW( LPCWSTR szDescriptor,
1654 LPWSTR szPath, LPDWORD pcchPath, LPDWORD pcchArgs )
1655 {
1656 FIXME("%s %p %p %p\n", debugstr_w(szDescriptor), szPath, pcchPath, pcchArgs );
1657 return ERROR_CALL_NOT_IMPLEMENTED;
1658 }
1659
1660 HRESULT WINAPI MsiGetFileSignatureInformationA( LPCSTR szSignedObjectPath,
1661 DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, LPBYTE pbHashData,
1662 LPDWORD pcbHashData)
1663 {
1664 FIXME("%s %08x %p %p %p\n", debugstr_a(szSignedObjectPath), dwFlags,
1665 ppcCertContext, pbHashData, pcbHashData);
1666 return ERROR_CALL_NOT_IMPLEMENTED;
1667 }
1668
1669 HRESULT WINAPI MsiGetFileSignatureInformationW( LPCWSTR szSignedObjectPath,
1670 DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, LPBYTE pbHashData,
1671 LPDWORD pcbHashData)
1672 {
1673 FIXME("%s %08x %p %p %p\n", debugstr_w(szSignedObjectPath), dwFlags,
1674 ppcCertContext, pbHashData, pcbHashData);
1675 return ERROR_CALL_NOT_IMPLEMENTED;
1676 }
1677
1678 UINT WINAPI MsiGetProductPropertyA( MSIHANDLE hProduct, LPCSTR szProperty,
1679 LPSTR szValue, LPDWORD pccbValue )
1680 {
1681 FIXME("%ld %s %p %p\n", hProduct, debugstr_a(szProperty), szValue, pccbValue);
1682 return ERROR_CALL_NOT_IMPLEMENTED;
1683 }
1684
1685 UINT WINAPI MsiGetProductPropertyW( MSIHANDLE hProduct, LPCWSTR szProperty,
1686 LPWSTR szValue, LPDWORD pccbValue )
1687 {
1688 FIXME("%ld %s %p %p\n", hProduct, debugstr_w(szProperty), szValue, pccbValue);
1689 return ERROR_CALL_NOT_IMPLEMENTED;
1690 }
1691
1692 UINT WINAPI MsiVerifyPackageA( LPCSTR szPackage )
1693 {
1694 UINT r;
1695 LPWSTR szPack = NULL;
1696
1697 TRACE("%s\n", debugstr_a(szPackage) );
1698
1699 if( szPackage )
1700 {
1701 szPack = strdupAtoW( szPackage );
1702 if( !szPack )
1703 return ERROR_OUTOFMEMORY;
1704 }
1705
1706 r = MsiVerifyPackageW( szPack );
1707
1708 msi_free( szPack );
1709
1710 return r;
1711 }
1712
1713 UINT WINAPI MsiVerifyPackageW( LPCWSTR szPackage )
1714 {
1715 MSIHANDLE handle;
1716 UINT r;
1717
1718 TRACE("%s\n", debugstr_w(szPackage) );
1719
1720 r = MsiOpenDatabaseW( szPackage, MSIDBOPEN_READONLY, &handle );
1721 MsiCloseHandle( handle );
1722
1723 return r;
1724 }
1725
1726 static INSTALLSTATE WINAPI MSI_GetComponentPath(LPCWSTR szProduct, LPCWSTR szComponent,
1727 awstring* lpPathBuf, LPDWORD pcchBuf)
1728 {
1729 WCHAR squished_pc[GUID_SIZE];
1730 WCHAR squished_comp[GUID_SIZE];
1731 HKEY hkey;
1732 LPWSTR path = NULL;
1733 INSTALLSTATE state;
1734 DWORD version;
1735
1736 static const WCHAR wininstaller[] = {
1737 'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0};
1738
1739 TRACE("%s %s %p %p\n", debugstr_w(szProduct),
1740 debugstr_w(szComponent), lpPathBuf->str.w, pcchBuf);
1741
1742 if (!szProduct || !szComponent)
1743 return INSTALLSTATE_INVALIDARG;
1744
1745 if (lpPathBuf->str.w && !pcchBuf)
1746 return INSTALLSTATE_INVALIDARG;
1747
1748 if (!squash_guid(szProduct, squished_pc) ||
1749 !squash_guid(szComponent, squished_comp))
1750 return INSTALLSTATE_INVALIDARG;
1751
1752 state = INSTALLSTATE_UNKNOWN;
1753
1754 if (MSIREG_OpenLocalSystemComponentKey(szComponent, &hkey, FALSE) == ERROR_SUCCESS ||
1755 MSIREG_OpenUserDataComponentKey(szComponent, &hkey, FALSE) == ERROR_SUCCESS)
1756 {
1757 path = msi_reg_get_val_str(hkey, squished_pc);
1758 RegCloseKey(hkey);
1759
1760 state = INSTALLSTATE_ABSENT;
1761
1762 if ((MSIREG_OpenLocalSystemProductKey(szProduct, &hkey, FALSE) == ERROR_SUCCESS ||
1763 MSIREG_OpenUserDataProductKey(szProduct, &hkey, FALSE) == ERROR_SUCCESS) &&
1764 msi_reg_get_val_dword(hkey, wininstaller, &version) &&
1765 GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
1766 {
1767 RegCloseKey(hkey);
1768 state = INSTALLSTATE_LOCAL;
1769 }
1770 }
1771
1772 if (state != INSTALLSTATE_LOCAL &&
1773 (MSIREG_OpenUserProductsKey(szProduct, &hkey, FALSE) == ERROR_SUCCESS ||
1774 MSIREG_OpenLocalClassesProductKey(szProduct, &hkey, FALSE) == ERROR_SUCCESS))
1775 {
1776 RegCloseKey(hkey);
1777
1778 if (MSIREG_OpenLocalSystemComponentKey(szComponent, &hkey, FALSE) == ERROR_SUCCESS ||
1779 MSIREG_OpenUserDataComponentKey(szComponent, &hkey, FALSE) == ERROR_SUCCESS)
1780 {
1781 msi_free(path);
1782 path = msi_reg_get_val_str(hkey, squished_pc);
1783 RegCloseKey(hkey);
1784
1785 state = INSTALLSTATE_ABSENT;
1786
1787 if (GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES)
1788 state = INSTALLSTATE_LOCAL;
1789 }
1790 }
1791
1792 if (!path)
1793 return INSTALLSTATE_UNKNOWN;
1794
1795 if (state == INSTALLSTATE_LOCAL && !*path)
1796 state = INSTALLSTATE_NOTUSED;
1797
1798 msi_strcpy_to_awstring(path, lpPathBuf, pcchBuf);
1799 msi_free(path);
1800 return state;
1801 }
1802
1803 /******************************************************************
1804 * MsiGetComponentPathW [MSI.@]
1805 */
1806 INSTALLSTATE WINAPI MsiGetComponentPathW(LPCWSTR szProduct, LPCWSTR szComponent,
1807 LPWSTR lpPathBuf, LPDWORD pcchBuf)
1808 {
1809 awstring path;
1810
1811 path.unicode = TRUE;
1812 path.str.w = lpPathBuf;
1813
1814 return MSI_GetComponentPath( szProduct, szComponent, &path, pcchBuf );
1815 }
1816
1817 /******************************************************************
1818 * MsiGetComponentPathA [MSI.@]
1819 */
1820 INSTALLSTATE WINAPI MsiGetComponentPathA(LPCSTR szProduct, LPCSTR szComponent,
1821 LPSTR lpPathBuf, LPDWORD pcchBuf)
1822 {
1823 LPWSTR szwProduct, szwComponent = NULL;
1824 INSTALLSTATE r = INSTALLSTATE_UNKNOWN;
1825 awstring path;
1826
1827 szwProduct = strdupAtoW( szProduct );
1828 if( szProduct && !szwProduct)
1829 goto end;
1830
1831 szwComponent = strdupAtoW( szComponent );
1832 if( szComponent && !szwComponent )
1833 goto end;
1834
1835 path.unicode = FALSE;
1836 path.str.a = lpPathBuf;
1837
1838 r = MSI_GetComponentPath( szwProduct, szwComponent, &path, pcchBuf );
1839
1840 end:
1841 msi_free( szwProduct );
1842 msi_free( szwComponent );
1843
1844 return r;
1845 }
1846
1847 /******************************************************************
1848 * MsiQueryFeatureStateA [MSI.@]
1849 */
1850 INSTALLSTATE WINAPI MsiQueryFeatureStateA(LPCSTR szProduct, LPCSTR szFeature)
1851 {
1852 LPWSTR szwProduct = NULL, szwFeature= NULL;
1853 INSTALLSTATE rc = INSTALLSTATE_UNKNOWN;
1854
1855 szwProduct = strdupAtoW( szProduct );
1856 if ( szProduct && !szwProduct )
1857 goto end;
1858
1859 szwFeature = strdupAtoW( szFeature );
1860 if ( szFeature && !szwFeature )
1861 goto end;
1862
1863 rc = MsiQueryFeatureStateW(szwProduct, szwFeature);
1864
1865 end:
1866 msi_free( szwProduct);
1867 msi_free( szwFeature);
1868
1869 return rc;
1870 }
1871
1872 /******************************************************************
1873 * MsiQueryFeatureStateW [MSI.@]
1874 *
1875 * Checks the state of a feature
1876 *
1877 * PARAMS
1878 * szProduct [I] Product's GUID string
1879 * szFeature [I] Feature's GUID string
1880 *
1881 * RETURNS
1882 * INSTALLSTATE_LOCAL Feature is installed and usable
1883 * INSTALLSTATE_ABSENT Feature is absent
1884 * INSTALLSTATE_ADVERTISED Feature should be installed on demand
1885 * INSTALLSTATE_UNKNOWN An error occurred
1886 * INSTALLSTATE_INVALIDARG One of the GUIDs was invalid
1887 *
1888 */
1889 INSTALLSTATE WINAPI MsiQueryFeatureStateW(LPCWSTR szProduct, LPCWSTR szFeature)
1890 {
1891 WCHAR squishProduct[33], comp[GUID_SIZE];
1892 GUID guid;
1893 LPWSTR components, p, parent_feature, path;
1894 UINT rc;
1895 HKEY hkey;
1896 INSTALLSTATE r;
1897 BOOL missing = FALSE;
1898 BOOL machine = FALSE;
1899
1900 TRACE("%s %s\n", debugstr_w(szProduct), debugstr_w(szFeature));
1901
1902 if (!szProduct || !szFeature)
1903 return INSTALLSTATE_INVALIDARG;
1904
1905 if (!squash_guid( szProduct, squishProduct ))
1906 return INSTALLSTATE_INVALIDARG;
1907
1908 if (MSIREG_OpenManagedFeaturesKey(szProduct, &hkey, FALSE) != ERROR_SUCCESS &&
1909 MSIREG_OpenUserFeaturesKey(szProduct, &hkey, FALSE) != ERROR_SUCCESS)
1910 {
1911 rc = MSIREG_OpenLocalClassesFeaturesKey(szProduct, &hkey, FALSE);
1912 if (rc != ERROR_SUCCESS)
1913 return INSTALLSTATE_UNKNOWN;
1914
1915 machine = TRUE;
1916 }
1917
1918 parent_feature = msi_reg_get_val_str( hkey, szFeature );
1919 RegCloseKey(hkey);
1920
1921 if (!parent_feature)
1922 return INSTALLSTATE_UNKNOWN;
1923
1924 r = (parent_feature[0] == 6) ? INSTALLSTATE_ABSENT : INSTALLSTATE_LOCAL;
1925 msi_free(parent_feature);
1926 if (r == INSTALLSTATE_ABSENT)
1927 return r;
1928
1929 if (machine)
1930 rc = MSIREG_OpenLocalUserDataFeaturesKey(szProduct, &hkey, FALSE);
1931 else
1932 rc = MSIREG_OpenUserDataFeaturesKey(szProduct, &hkey, FALSE);
1933
1934 if (rc != ERROR_SUCCESS)
1935 return INSTALLSTATE_ADVERTISED;
1936
1937 components = msi_reg_get_val_str( hkey, szFeature );
1938 RegCloseKey(hkey);
1939
1940 TRACE("rc = %d buffer = %s\n", rc, debugstr_w(components));
1941
1942 if (!components)
1943 return INSTALLSTATE_ADVERTISED;
1944
1945 for( p = components; *p && *p != 2 ; p += 20)
1946 {
1947 if (!decode_base85_guid( p, &guid ))
1948 {
1949 if (p != components)
1950 break;
1951
1952 msi_free(components);
1953 return INSTALLSTATE_BADCONFIG;
1954 }
1955
1956 StringFromGUID2(&guid, comp, GUID_SIZE);
1957
1958 if (machine)
1959 rc = MSIREG_OpenLocalUserDataComponentKey(comp, &hkey, FALSE);
1960 else
1961 rc = MSIREG_OpenUserDataComponentKey(comp, &hkey, FALSE);
1962
1963 if (rc != ERROR_SUCCESS)
1964 {
1965 msi_free(components);
1966 return INSTALLSTATE_ADVERTISED;
1967 }
1968
1969 path = msi_reg_get_val_str(hkey, squishProduct);
1970 if (!path)
1971 missing = TRUE;
1972
1973 msi_free(path);
1974 }
1975
1976 TRACE("%s %s -> %d\n", debugstr_w(szProduct), debugstr_w(szFeature), r);
1977 msi_free(components);
1978
1979 if (missing)
1980 return INSTALLSTATE_ADVERTISED;
1981
1982 return INSTALLSTATE_LOCAL;
1983 }
1984
1985 /******************************************************************
1986 * MsiGetFileVersionA [MSI.@]
1987 */
1988 UINT WINAPI MsiGetFileVersionA(LPCSTR szFilePath, LPSTR lpVersionBuf,
1989 LPDWORD pcchVersionBuf, LPSTR lpLangBuf, LPDWORD pcchLangBuf)
1990 {
1991 LPWSTR szwFilePath = NULL, lpwVersionBuff = NULL, lpwLangBuff = NULL;
1992 UINT ret = ERROR_OUTOFMEMORY;
1993
1994 if ((lpVersionBuf && !pcchVersionBuf) ||
1995 (lpLangBuf && !pcchLangBuf))
1996 return ERROR_INVALID_PARAMETER;
1997
1998 if( szFilePath )
1999 {
2000 szwFilePath = strdupAtoW( szFilePath );
2001 if( !szwFilePath )
2002 goto end;
2003 }
2004
2005 if( lpVersionBuf && pcchVersionBuf && *pcchVersionBuf )
2006 {
2007 lpwVersionBuff = msi_alloc(*pcchVersionBuf*sizeof(WCHAR));
2008 if( !lpwVersionBuff )
2009 goto end;
2010 }
2011
2012 if( lpLangBuf && pcchLangBuf && *pcchLangBuf )
2013 {
2014 lpwLangBuff = msi_alloc(*pcchLangBuf*sizeof(WCHAR));
2015 if( !lpwLangBuff )
2016 goto end;
2017 }
2018
2019 ret = MsiGetFileVersionW(szwFilePath, lpwVersionBuff, pcchVersionBuf,
2020 lpwLangBuff, pcchLangBuf);
2021
2022 if( (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && lpwVersionBuff )
2023 WideCharToMultiByte(CP_ACP, 0, lpwVersionBuff, -1,
2024 lpVersionBuf, *pcchVersionBuf + 1, NULL, NULL);
2025 if( (ret == ERROR_SUCCESS || ret == ERROR_MORE_DATA) && lpwLangBuff )
2026 WideCharToMultiByte(CP_ACP, 0, lpwLangBuff, -1,
2027 lpLangBuf, *pcchLangBuf + 1, NULL, NULL);
2028
2029 end:
2030 msi_free(szwFilePath);
2031 msi_free(lpwVersionBuff);
2032 msi_free(lpwLangBuff);
2033
2034 return ret;
2035 }
2036
2037 /******************************************************************
2038 * MsiGetFileVersionW [MSI.@]
2039 */
2040 UINT WINAPI MsiGetFileVersionW(LPCWSTR szFilePath, LPWSTR lpVersionBuf,
2041 LPDWORD pcchVersionBuf, LPWSTR lpLangBuf, LPDWORD pcchLangBuf)
2042 {
2043 static const WCHAR szVersionResource[] = {'\\',0};
2044 static const WCHAR szVersionFormat[] = {
2045 '%','d','.','%','d','.','%','d','.','%','d',0};
2046 static const WCHAR szLangResource[] = {
2047 '\\','V','a','r','F','i','l','e','I','n','f','o','\\',
2048 'T','r','a','n','s','l','a','t','i','o','n',0};
2049 static const WCHAR szLangFormat[] = {'%','d',0};
2050 UINT ret = 0;
2051 DWORD dwVerLen, gle;
2052 LPVOID lpVer = NULL;
2053 VS_FIXEDFILEINFO *ffi;
2054 USHORT *lang;
2055 UINT puLen;
2056 WCHAR tmp[32];
2057
2058 TRACE("%s %p %d %p %d\n", debugstr_w(szFilePath),
2059 lpVersionBuf, pcchVersionBuf?*pcchVersionBuf:0,
2060 lpLangBuf, pcchLangBuf?*pcchLangBuf:0);
2061
2062 if ((lpVersionBuf && !pcchVersionBuf) ||
2063 (lpLangBuf && !pcchLangBuf))
2064 return ERROR_INVALID_PARAMETER;
2065
2066 dwVerLen = GetFileVersionInfoSizeW(szFilePath, NULL);
2067 if( !dwVerLen )
2068 {
2069 gle = GetLastError();
2070 if (gle == ERROR_BAD_PATHNAME)
2071 return ERROR_FILE_NOT_FOUND;
2072 else if (gle == ERROR_RESOURCE_DATA_NOT_FOUND)
2073 return ERROR_FILE_INVALID;
2074
2075 return gle;
2076 }
2077
2078 lpVer = msi_alloc(dwVerLen);
2079 if( !lpVer )
2080 {
2081 ret = ERROR_OUTOFMEMORY;
2082 goto end;
2083 }
2084
2085 if( !GetFileVersionInfoW(szFilePath, 0, dwVerLen, lpVer) )
2086 {
2087 ret = GetLastError();
2088 goto end;
2089 }
2090
2091 if (pcchVersionBuf)
2092 {
2093 if( VerQueryValueW(lpVer, szVersionResource, (LPVOID*)&ffi, &puLen) &&
2094 (puLen > 0) )
2095 {
2096 wsprintfW(tmp, szVersionFormat,
2097 HIWORD(ffi->dwFileVersionMS), LOWORD(ffi->dwFileVersionMS),
2098 HIWORD(ffi->dwFileVersionLS), LOWORD(ffi->dwFileVersionLS));
2099 if (lpVersionBuf) lstrcpynW(lpVersionBuf, tmp, *pcchVersionBuf);
2100
2101 if (lstrlenW(tmp) >= *pcchVersionBuf)
2102 ret = ERROR_MORE_DATA;
2103
2104 *pcchVersionBuf = lstrlenW(tmp);
2105 }
2106 else
2107 {
2108 if (lpVersionBuf) *lpVersionBuf = 0;
2109 *pcchVersionBuf = 0;
2110 }
2111 }
2112
2113 if (pcchLangBuf)
2114 {
2115 if (VerQueryValueW(lpVer, szLangResource, (LPVOID*)&lang, &puLen) &&
2116 (puLen > 0))
2117 {
2118 wsprintfW(tmp, szLangFormat, *lang);
2119 if (lpLangBuf) lstrcpynW(lpLangBuf, tmp, *pcchLangBuf);
2120
2121 if (lstrlenW(tmp) >= *pcchLangBuf)
2122 ret = ERROR_MORE_DATA;
2123
2124 *pcchLangBuf = lstrlenW(tmp);
2125 }
2126 else
2127 {
2128 if (lpLangBuf) *lpLangBuf = 0;
2129 *pcchLangBuf = 0;
2130 }
2131 }
2132
2133 end:
2134 msi_free(lpVer);
2135 return ret;
2136 }
2137
2138 /***********************************************************************
2139 * MsiGetFeatureUsageW [MSI.@]
2140 */
2141 UINT WINAPI MsiGetFeatureUsageW( LPCWSTR szProduct, LPCWSTR szFeature,
2142 LPDWORD pdwUseCount, LPWORD pwDateUsed )
2143 {
2144 FIXME("%s %s %p %p\n",debugstr_w(szProduct), debugstr_w(szFeature),
2145 pdwUseCount, pwDateUsed);
2146 return ERROR_CALL_NOT_IMPLEMENTED;
2147 }
2148
2149 /***********************************************************************
2150 * MsiGetFeatureUsageA [MSI.@]
2151 */
2152 UINT WINAPI MsiGetFeatureUsageA( LPCSTR szProduct, LPCSTR szFeature,
2153 LPDWORD pdwUseCount, LPWORD pwDateUsed )
2154 {
2155 LPWSTR prod = NULL, feat = NULL;
2156 UINT ret = ERROR_OUTOFMEMORY;
2157
2158 TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szFeature),
2159 pdwUseCount, pwDateUsed);
2160
2161 prod = strdupAtoW( szProduct );
2162 if (szProduct && !prod)
2163 goto end;
2164
2165 feat = strdupAtoW( szFeature );
2166 if (szFeature && !feat)
2167 goto end;
2168
2169 ret = MsiGetFeatureUsageW( prod, feat, pdwUseCount, pwDateUsed );
2170
2171 end:
2172 msi_free( prod );
2173 msi_free( feat );
2174
2175 return ret;
2176 }
2177
2178 /***********************************************************************
2179 * MsiUseFeatureExW [MSI.@]
2180 */
2181 INSTALLSTATE WINAPI MsiUseFeatureExW( LPCWSTR szProduct, LPCWSTR szFeature,
2182 DWORD dwInstallMode, DWORD dwReserved )
2183 {
2184 INSTALLSTATE state;
2185
2186 TRACE("%s %s %i %i\n", debugstr_w(szProduct), debugstr_w(szFeature),
2187 dwInstallMode, dwReserved);
2188
2189 state = MsiQueryFeatureStateW( szProduct, szFeature );
2190
2191 if (dwReserved)
2192 return INSTALLSTATE_INVALIDARG;
2193
2194 if (state == INSTALLSTATE_LOCAL && dwInstallMode != INSTALLMODE_NODETECTION)
2195 {
2196 FIXME("mark product %s feature %s as used\n",
2197 debugstr_w(szProduct), debugstr_w(szFeature) );
2198 }
2199
2200 return state;
2201 }
2202
2203 /***********************************************************************
2204 * MsiUseFeatureExA [MSI.@]
2205 */
2206 INSTALLSTATE WINAPI MsiUseFeatureExA( LPCSTR szProduct, LPCSTR szFeature,
2207 DWORD dwInstallMode, DWORD dwReserved )
2208 {
2209 INSTALLSTATE ret = INSTALLSTATE_UNKNOWN;
2210 LPWSTR prod = NULL, feat = NULL;
2211
2212 TRACE("%s %s %i %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
2213 dwInstallMode, dwReserved);
2214
2215 prod = strdupAtoW( szProduct );
2216 if (szProduct && !prod)
2217 goto end;
2218
2219 feat = strdupAtoW( szFeature );
2220 if (szFeature && !feat)
2221 goto end;
2222
2223 ret = MsiUseFeatureExW( prod, feat, dwInstallMode, dwReserved );
2224
2225 end:
2226 msi_free( prod );
2227 msi_free( feat );
2228
2229 return ret;
2230 }
2231
2232 /***********************************************************************
2233 * MsiUseFeatureW [MSI.@]
2234 */
2235 INSTALLSTATE WINAPI MsiUseFeatureW( LPCWSTR szProduct, LPCWSTR szFeature )
2236 {
2237 return MsiUseFeatureExW(szProduct, szFeature, 0, 0);
2238 }
2239
2240 /***********************************************************************
2241 * MsiUseFeatureA [MSI.@]
2242 */
2243 INSTALLSTATE WINAPI MsiUseFeatureA( LPCSTR szProduct, LPCSTR szFeature )
2244 {
2245 return MsiUseFeatureExA(szProduct, szFeature, 0, 0);
2246 }
2247
2248 /***********************************************************************
2249 * MSI_ProvideQualifiedComponentEx [internal]
2250 */
2251 static UINT WINAPI MSI_ProvideQualifiedComponentEx(LPCWSTR szComponent,
2252 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
2253 DWORD Unused1, DWORD Unused2, awstring *lpPathBuf,
2254 LPDWORD pcchPathBuf)
2255 {
2256 WCHAR product[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1],
2257 feature[MAX_FEATURE_CHARS+1];
2258 LPWSTR info;
2259 HKEY hkey;
2260 DWORD sz;
2261 UINT rc;
2262
2263 TRACE("%s %s %i %s %i %i %p %p\n", debugstr_w(szComponent),
2264 debugstr_w(szQualifier), dwInstallMode, debugstr_w(szProduct),
2265 Unused1, Unused2, lpPathBuf, pcchPathBuf);
2266
2267 rc = MSIREG_OpenUserComponentsKey(szComponent, &hkey, FALSE);
2268 if (rc != ERROR_SUCCESS)
2269 return ERROR_INDEX_ABSENT;
2270
2271 info = msi_reg_get_val_str( hkey, szQualifier );
2272 RegCloseKey(hkey);
2273
2274 if (!info)
2275 return ERROR_INDEX_ABSENT;
2276
2277 MsiDecomposeDescriptorW(info, product, feature, component, &sz);
2278
2279 if (!szProduct)
2280 rc = MSI_GetComponentPath(product, component, lpPathBuf, pcchPathBuf);
2281 else
2282 rc = MSI_GetComponentPath(szProduct, component, lpPathBuf, pcchPathBuf);
2283
2284 msi_free( info );
2285
2286 if (rc != INSTALLSTATE_LOCAL)
2287 return ERROR_FILE_NOT_FOUND;
2288
2289 return ERROR_SUCCESS;
2290 }
2291
2292 /***********************************************************************
2293 * MsiProvideQualifiedComponentExW [MSI.@]
2294 */
2295 UINT WINAPI MsiProvideQualifiedComponentExW(LPCWSTR szComponent,
2296 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
2297 DWORD Unused1, DWORD Unused2, LPWSTR lpPathBuf,
2298 LPDWORD pcchPathBuf)
2299 {
2300 awstring path;
2301
2302 path.unicode = TRUE;
2303 path.str.w = lpPathBuf;
2304
2305 return MSI_ProvideQualifiedComponentEx(szComponent, szQualifier,
2306 dwInstallMode, szProduct, Unused1, Unused2, &path, pcchPathBuf);
2307 }
2308
2309 /***********************************************************************
2310 * MsiProvideQualifiedComponentExA [MSI.@]
2311 */
2312 UINT WINAPI MsiProvideQualifiedComponentExA(LPCSTR szComponent,
2313 LPCSTR szQualifier, DWORD dwInstallMode, LPCSTR szProduct,
2314 DWORD Unused1, DWORD Unused2, LPSTR lpPathBuf,
2315 LPDWORD pcchPathBuf)
2316 {
2317 LPWSTR szwComponent, szwQualifier = NULL, szwProduct = NULL;
2318 UINT r = ERROR_OUTOFMEMORY;
2319 awstring path;
2320
2321 TRACE("%s %s %u %s %u %u %p %p\n", debugstr_a(szComponent),
2322 debugstr_a(szQualifier), dwInstallMode, debugstr_a(szProduct),
2323 Unused1, Unused2, lpPathBuf, pcchPathBuf);
2324
2325 szwComponent = strdupAtoW( szComponent );
2326 if (szComponent && !szwComponent)
2327 goto end;
2328
2329 szwQualifier = strdupAtoW( szQualifier );
2330 if (szQualifier && !szwQualifier)
2331 goto end;
2332
2333 szwProduct = strdupAtoW( szProduct );
2334 if (szProduct && !szwProduct)
2335 goto end;
2336
2337 path.unicode = FALSE;
2338 path.str.a = lpPathBuf;
2339
2340 r = MSI_ProvideQualifiedComponentEx(szwComponent, szwQualifier,
2341 dwInstallMode, szwProduct, Unused1,
2342 Unused2, &path, pcchPathBuf);
2343 end:
2344 msi_free(szwProduct);
2345 msi_free(szwComponent);
2346 msi_free(szwQualifier);
2347
2348 return r;
2349 }
2350
2351 /***********************************************************************
2352 * MsiProvideQualifiedComponentW [MSI.@]
2353 */
2354 UINT WINAPI MsiProvideQualifiedComponentW( LPCWSTR szComponent,
2355 LPCWSTR szQualifier, DWORD dwInstallMode, LPWSTR lpPathBuf,
2356 LPDWORD pcchPathBuf)
2357 {
2358 return MsiProvideQualifiedComponentExW(szComponent, szQualifier,
2359 dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
2360 }
2361
2362 /***********************************************************************
2363 * MsiProvideQualifiedComponentA [MSI.@]
2364 */
2365 UINT WINAPI MsiProvideQualifiedComponentA( LPCSTR szComponent,
2366 LPCSTR szQualifier, DWORD dwInstallMode, LPSTR lpPathBuf,
2367 LPDWORD pcchPathBuf)
2368 {
2369 return MsiProvideQualifiedComponentExA(szComponent, szQualifier,
2370 dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
2371 }
2372
2373 /***********************************************************************
2374 * MSI_GetUserInfo [internal]
2375 */
2376 static USERINFOSTATE WINAPI MSI_GetUserInfo(LPCWSTR szProduct,
2377 awstring *lpUserNameBuf, LPDWORD pcchUserNameBuf,
2378 awstring *lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
2379 awstring *lpSerialBuf, LPDWORD pcchSerialBuf)
2380 {
2381 WCHAR squished_pc[SQUISH_GUID_SIZE];
2382 LPWSTR user, org, serial;
2383 USERINFOSTATE state;
2384 HKEY hkey, props;
2385 LPCWSTR orgptr;
2386 UINT r;
2387
2388 static const WCHAR szEmpty[] = {0};
2389
2390 TRACE("%s %p %p %p %p %p %p\n", debugstr_w(szProduct), lpUserNameBuf,
2391 pcchUserNameBuf, lpOrgNameBuf, pcchOrgNameBuf, lpSerialBuf,
2392 pcchSerialBuf);
2393
2394 if (!szProduct || !squash_guid(szProduct, squished_pc))
2395 return USERINFOSTATE_INVALIDARG;
2396
2397 if (MSIREG_OpenLocalManagedProductKey(szProduct, &hkey, FALSE) != ERROR_SUCCESS &&
2398 MSIREG_OpenUserProductsKey(szProduct, &hkey, FALSE) != ERROR_SUCCESS &&
2399 MSIREG_OpenLocalClassesProductKey(szProduct, &hkey, FALSE) != ERROR_SUCCESS)
2400 {
2401 return USERINFOSTATE_UNKNOWN;
2402 }
2403
2404 if (MSIREG_OpenCurrentUserInstallProps(szProduct, &props, FALSE) != ERROR_SUCCESS &&
2405 MSIREG_OpenLocalSystemInstallProps(szProduct, &props, FALSE) != ERROR_SUCCESS)
2406 {
2407 RegCloseKey(hkey);
2408 return USERINFOSTATE_ABSENT;
2409 }
2410
2411 user = msi_reg_get_val_str(props, INSTALLPROPERTY_REGOWNERW);
2412 org = msi_reg_get_val_str(props, INSTALLPROPERTY_REGCOMPANYW);
2413 serial = msi_reg_get_val_str(props, INSTALLPROPERTY_PRODUCTIDW);
2414 state = USERINFOSTATE_ABSENT;
2415
2416 RegCloseKey(hkey);
2417 RegCloseKey(props);
2418
2419 if (user && serial)
2420 state = USERINFOSTATE_PRESENT;
2421
2422 if (pcchUserNameBuf)
2423 {
2424 if (lpUserNameBuf && !user)
2425 {
2426 (*pcchUserNameBuf)--;
2427 goto done;
2428 }
2429
2430 r = msi_strcpy_to_awstring(user, lpUserNameBuf, pcchUserNameBuf);
2431 if (r == ERROR_MORE_DATA)
2432 {
2433 state = USERINFOSTATE_MOREDATA;
2434 goto done;
2435 }
2436 }
2437
2438 if (pcchOrgNameBuf)
2439 {
2440 orgptr = org;
2441 if (!orgptr) orgptr = szEmpty;
2442
2443 r = msi_strcpy_to_awstring(orgptr, lpOrgNameBuf, pcchOrgNameBuf);
2444 if (r == ERROR_MORE_DATA)
2445 {
2446 state = USERINFOSTATE_MOREDATA;
2447 goto done;
2448 }
2449 }
2450
2451 if (pcchSerialBuf)
2452 {
2453 if (!serial)
2454 {
2455 (*pcchSerialBuf)--;
2456 goto done;
2457 }
2458
2459 r = msi_strcpy_to_awstring(serial, lpSerialBuf, pcchSerialBuf);
2460 if (r == ERROR_MORE_DATA)
2461 state = USERINFOSTATE_MOREDATA;
2462 }
2463
2464 done:
2465 msi_free(user);
2466 msi_free(org);
2467 msi_free(serial);
2468
2469 return state;
2470 }
2471
2472 /***********************************************************************
2473 * MsiGetUserInfoW [MSI.@]
2474 */
2475 USERINFOSTATE WINAPI MsiGetUserInfoW(LPCWSTR szProduct,
2476 LPWSTR lpUserNameBuf, LPDWORD pcchUserNameBuf,
2477 LPWSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
2478 LPWSTR lpSerialBuf, LPDWORD pcchSerialBuf)
2479 {
2480 awstring user, org, serial;
2481
2482 if ((lpUserNameBuf && !pcchUserNameBuf) ||
2483 (lpOrgNameBuf && !pcchOrgNameBuf) ||
2484 (lpSerialBuf && !pcchSerialBuf))
2485 return USERINFOSTATE_INVALIDARG;
2486
2487 user.unicode = TRUE;
2488 user.str.w = lpUserNameBuf;
2489 org.unicode = TRUE;
2490 org.str.w = lpOrgNameBuf;
2491 serial.unicode = TRUE;
2492 serial.str.w = lpSerialBuf;
2493
2494 return MSI_GetUserInfo( szProduct, &user, pcchUserNameBuf,
2495 &org, pcchOrgNameBuf,
2496 &serial, pcchSerialBuf );
2497 }
2498
2499 USERINFOSTATE WINAPI MsiGetUserInfoA(LPCSTR szProduct,
2500 LPSTR lpUserNameBuf, LPDWORD pcchUserNameBuf,
2501 LPSTR lpOrgNameBuf, LPDWORD pcchOrgNameBuf,
2502 LPSTR lpSerialBuf, LPDWORD pcchSerialBuf)
2503 {
2504 awstring user, org, serial;
2505 LPWSTR prod;
2506 UINT r;
2507
2508 if ((lpUserNameBuf && !pcchUserNameBuf) ||
2509 (lpOrgNameBuf && !pcchOrgNameBuf) ||
2510 (lpSerialBuf && !pcchSerialBuf))
2511 return USERINFOSTATE_INVALIDARG;
2512
2513 prod = strdupAtoW( szProduct );
2514 if (szProduct && !prod)
2515 return ERROR_OUTOFMEMORY;
2516
2517 user.unicode = FALSE;
2518 user.str.a = lpUserNameBuf;
2519 org.unicode = FALSE;
2520 org.str.a = lpOrgNameBuf;
2521 serial.unicode = FALSE;
2522 serial.str.a = lpSerialBuf;
2523
2524 r = MSI_GetUserInfo( prod, &user, pcchUserNameBuf,
2525 &org, pcchOrgNameBuf,
2526 &serial, pcchSerialBuf );
2527
2528 msi_free( prod );
2529
2530 return r;
2531 }
2532
2533 UINT WINAPI MsiCollectUserInfoW(LPCWSTR szProduct)
2534 {
2535 MSIHANDLE handle;
2536 UINT rc;
2537 MSIPACKAGE *package;
2538 static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
2539
2540 TRACE("(%s)\n",debugstr_w(szProduct));
2541
2542 rc = MsiOpenProductW(szProduct,&handle);
2543 if (rc != ERROR_SUCCESS)
2544 return ERROR_INVALID_PARAMETER;
2545
2546 package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
2547 rc = ACTION_PerformUIAction(package, szFirstRun, -1);
2548 msiobj_release( &package->hdr );
2549
2550 MsiCloseHandle(handle);
2551
2552 return rc;
2553 }
2554
2555 UINT WINAPI MsiCollectUserInfoA(LPCSTR szProduct)
2556 {
2557 MSIHANDLE handle;
2558 UINT rc;
2559 MSIPACKAGE *package;
2560 static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
2561
2562 TRACE("(%s)\n",debugstr_a(szProduct));
2563
2564 rc = MsiOpenProductA(szProduct,&handle);
2565 if (rc != ERROR_SUCCESS)
2566 return ERROR_INVALID_PARAMETER;
2567
2568 package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
2569 rc = ACTION_PerformUIAction(package, szFirstRun, -1);
2570 msiobj_release( &package->hdr );
2571
2572 MsiCloseHandle(handle);
2573
2574 return rc;
2575 }
2576
2577 /***********************************************************************
2578 * MsiConfigureFeatureA [MSI.@]
2579 */
2580 UINT WINAPI MsiConfigureFeatureA(LPCSTR szProduct, LPCSTR szFeature, INSTALLSTATE eInstallState)
2581 {
2582 LPWSTR prod, feat = NULL;
2583 UINT r = ERROR_OUTOFMEMORY;
2584
2585 TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature), eInstallState);
2586
2587 prod = strdupAtoW( szProduct );
2588 if (szProduct && !prod)
2589 goto end;
2590
2591 feat = strdupAtoW( szFeature );
2592 if (szFeature && !feat)
2593 goto end;
2594
2595 r = MsiConfigureFeatureW(prod, feat, eInstallState);
2596
2597 end:
2598 msi_free(feat);
2599 msi_free(prod);
2600
2601 return r;
2602 }
2603
2604 /***********************************************************************
2605 * MsiConfigureFeatureW [MSI.@]
2606 */
2607 UINT WINAPI MsiConfigureFeatureW(LPCWSTR szProduct, LPCWSTR szFeature, INSTALLSTATE eInstallState)
2608 {
2609 static const WCHAR szCostInit[] = { 'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0 };
2610 MSIPACKAGE *package = NULL;
2611 UINT r;
2612 WCHAR sourcepath[MAX_PATH], filename[MAX_PATH];
2613 DWORD sz;
2614
2615 TRACE("%s %s %i\n", debugstr_w(szProduct), debugstr_w(szFeature), eInstallState);
2616
2617 if (!szProduct || !szFeature)
2618 return ERROR_INVALID_PARAMETER;
2619
2620 switch (eInstallState)
2621 {
2622 case INSTALLSTATE_DEFAULT:
2623 /* FIXME: how do we figure out the default location? */
2624 eInstallState = INSTALLSTATE_LOCAL;
2625 break;
2626 case INSTALLSTATE_LOCAL:
2627 case INSTALLSTATE_SOURCE:
2628 case INSTALLSTATE_ABSENT:
2629 case INSTALLSTATE_ADVERTISED:
2630 break;
2631 default:
2632 return ERROR_INVALID_PARAMETER;
2633 }
2634
2635 r = MSI_OpenProductW( szProduct, &package );
2636 if (r != ERROR_SUCCESS)
2637 return r;
2638
2639 sz = sizeof(sourcepath);
2640 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2641 MSICODE_PRODUCT, INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
2642
2643 sz = sizeof(filename);
2644 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2645 MSICODE_PRODUCT, INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
2646
2647 lstrcatW( sourcepath, filename );
2648
2649 MsiSetInternalUI( INSTALLUILEVEL_BASIC, NULL );
2650
2651 r = ACTION_PerformUIAction( package, szCostInit, -1 );
2652 if (r != ERROR_SUCCESS)
2653 goto end;
2654
2655 r = MSI_SetFeatureStateW( package, szFeature, eInstallState);
2656 if (r != ERROR_SUCCESS)
2657 goto end;
2658
2659 r = MSI_InstallPackage( package, sourcepath, NULL );
2660
2661 end:
2662 msiobj_release( &package->hdr );
2663
2664 return r;
2665 }
2666
2667 /***********************************************************************
2668 * MsiCreateAndVerifyInstallerDirectory [MSI.@]
2669 *
2670 * Notes: undocumented
2671 */
2672 UINT WINAPI MsiCreateAndVerifyInstallerDirectory(DWORD dwReserved)
2673 {
2674 WCHAR path[MAX_PATH];
2675
2676 TRACE("%d\n", dwReserved);
2677
2678 if (dwReserved)
2679 {
2680 FIXME("dwReserved=%d\n", dwReserved);
2681 return ERROR_INVALID_PARAMETER;
2682 }
2683
2684 if (!GetWindowsDirectoryW(path, MAX_PATH))
2685 return ERROR_FUNCTION_FAILED;
2686
2687 lstrcatW(path, installerW);
2688
2689 if (!CreateDirectoryW(path, NULL))
2690 return ERROR_FUNCTION_FAILED;
2691
2692 return ERROR_SUCCESS;
2693 }
2694
2695 /***********************************************************************
2696 * MsiGetShortcutTargetA [MSI.@]
2697 */
2698 UINT WINAPI MsiGetShortcutTargetA( LPCSTR szShortcutTarget,
2699 LPSTR szProductCode, LPSTR szFeatureId,
2700 LPSTR szComponentCode )
2701 {
2702 LPWSTR target;
2703 const int len = MAX_FEATURE_CHARS+1;
2704 WCHAR product[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1];
2705 UINT r;
2706
2707 target = strdupAtoW( szShortcutTarget );
2708 if (szShortcutTarget && !target )
2709 return ERROR_OUTOFMEMORY;
2710 product[0] = 0;
2711 feature[0] = 0;
2712 component[0] = 0;
2713 r = MsiGetShortcutTargetW( target, product, feature, component );
2714 msi_free( target );
2715 if (r == ERROR_SUCCESS)
2716 {
2717 WideCharToMultiByte( CP_ACP, 0, product, -1, szProductCode, len, NULL, NULL );
2718 WideCharToMultiByte( CP_ACP, 0, feature, -1, szFeatureId, len, NULL, NULL );
2719 WideCharToMultiByte( CP_ACP, 0, component, -1, szComponentCode, len, NULL, NULL );
2720 }
2721 return r;
2722 }
2723
2724 /***********************************************************************
2725 * MsiGetShortcutTargetW [MSI.@]
2726 */
2727 UINT WINAPI MsiGetShortcutTargetW( LPCWSTR szShortcutTarget,
2728 LPWSTR szProductCode, LPWSTR szFeatureId,
2729 LPWSTR szComponentCode )
2730 {
2731 IShellLinkDataList *dl = NULL;
2732 IPersistFile *pf = NULL;
2733 LPEXP_DARWIN_LINK darwin = NULL;
2734 HRESULT r, init;
2735
2736 TRACE("%s %p %p %p\n", debugstr_w(szShortcutTarget),
2737 szProductCode, szFeatureId, szComponentCode );
2738
2739 init = CoInitialize(NULL);
2740
2741 r = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
2742 &IID_IPersistFile, (LPVOID*) &pf );
2743 if( SUCCEEDED( r ) )
2744 {
2745 r = IPersistFile_Load( pf, szShortcutTarget,
2746 STGM_READ | STGM_SHARE_DENY_WRITE );
2747 if( SUCCEEDED( r ) )
2748 {
2749 r = IPersistFile_QueryInterface( pf, &IID_IShellLinkDataList,
2750 (LPVOID*) &dl );
2751 if( SUCCEEDED( r ) )
2752 {
2753 IShellLinkDataList_CopyDataBlock( dl, EXP_DARWIN_ID_SIG,
2754 (LPVOID) &darwin );
2755 IShellLinkDataList_Release( dl );
2756 }
2757 }
2758 IPersistFile_Release( pf );
2759 }
2760
2761 if (SUCCEEDED(init))
2762 CoUninitialize();
2763
2764 TRACE("darwin = %p\n", darwin);
2765
2766 if (darwin)
2767 {
2768 DWORD sz;
2769 UINT ret;
2770
2771 ret = MsiDecomposeDescriptorW( darwin->szwDarwinID,
2772 szProductCode, szFeatureId, szComponentCode, &sz );
2773 LocalFree( darwin );
2774 return ret;
2775 }
2776
2777 return ERROR_FUNCTION_FAILED;
2778 }
2779
2780 UINT WINAPI MsiReinstallFeatureW( LPCWSTR szProduct, LPCWSTR szFeature,
2781 DWORD dwReinstallMode )
2782 {
2783 MSIPACKAGE* package = NULL;
2784 UINT r;
2785 WCHAR sourcepath[MAX_PATH];
2786 WCHAR filename[MAX_PATH];
2787 static const WCHAR szLogVerbose[] = {
2788 ' ','L','O','G','V','E','R','B','O','S','E',0 };
2789 static const WCHAR szInstalled[] = { 'I','n','s','t','a','l','l','e','d',0};
2790 static const WCHAR szReinstall[] = {'R','E','I','N','S','T','A','L','L',0};
2791 static const WCHAR szReinstallMode[] = {'R','E','I','N','S','T','A','L','L','M','O','D','E',0};
2792 static const WCHAR szOne[] = {'1',0};
2793 WCHAR reinstallmode[11];
2794 LPWSTR ptr;
2795 DWORD sz;
2796
2797 FIXME("%s %s %i\n", debugstr_w(szProduct), debugstr_w(szFeature),
2798 dwReinstallMode);
2799
2800 ptr = reinstallmode;
2801
2802 if (dwReinstallMode & REINSTALLMODE_FILEMISSING)
2803 *ptr++ = 'p';
2804 if (dwReinstallMode & REINSTALLMODE_FILEOLDERVERSION)
2805 *ptr++ = 'o';
2806 if (dwReinstallMode & REINSTALLMODE_FILEEQUALVERSION)
2807 *ptr++ = 'w';
2808 if (dwReinstallMode & REINSTALLMODE_FILEEXACT)
2809 *ptr++ = 'd';
2810 if (dwReinstallMode & REINSTALLMODE_FILEVERIFY)
2811 *ptr++ = 'c';
2812 if (dwReinstallMode & REINSTALLMODE_FILEREPLACE)
2813 *ptr++ = 'a';
2814 if (dwReinstallMode & REINSTALLMODE_USERDATA)
2815 *ptr++ = 'u';
2816 if (dwReinstallMode & REINSTALLMODE_MACHINEDATA)
2817 *ptr++ = 'm';
2818 if (dwReinstallMode & REINSTALLMODE_SHORTCUT)
2819 *ptr++ = 's';
2820 if (dwReinstallMode & REINSTALLMODE_PACKAGE)
2821 *ptr++ = 'v';
2822 *ptr = 0;
2823
2824 sz = sizeof(sourcepath);
2825 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2826 MSICODE_PRODUCT, INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
2827
2828 sz = sizeof(filename);
2829 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERUNMANAGED,
2830 MSICODE_PRODUCT, INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
2831
2832 lstrcatW( sourcepath, filename );
2833
2834 if (dwReinstallMode & REINSTALLMODE_PACKAGE)
2835 r = MSI_OpenPackageW( sourcepath, &package );
2836 else
2837 r = MSI_OpenProductW( szProduct, &package );
2838
2839 if (r != ERROR_SUCCESS)
2840 return r;
2841
2842 MSI_SetPropertyW( package, szReinstallMode, reinstallmode );
2843 MSI_SetPropertyW( package, szInstalled, szOne );
2844 MSI_SetPropertyW( package, szLogVerbose, szOne );
2845 MSI_SetPropertyW( package, szReinstall, szFeature );
2846
2847 r = MSI_InstallPackage( package, sourcepath, NULL );
2848
2849 msiobj_release( &package->hdr );
2850
2851 return r;
2852 }
2853
2854 UINT WINAPI MsiReinstallFeatureA( LPCSTR szProduct, LPCSTR szFeature,
2855 DWORD dwReinstallMode )
2856 {
2857 LPWSTR wszProduct;
2858 LPWSTR wszFeature;
2859 UINT rc;
2860
2861 TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
2862 dwReinstallMode);
2863
2864 wszProduct = strdupAtoW(szProduct);
2865 wszFeature = strdupAtoW(szFeature);
2866
2867 rc = MsiReinstallFeatureW(wszProduct, wszFeature, dwReinstallMode);
2868
2869 msi_free(wszProduct);
2870 msi_free(wszFeature);
2871 return rc;
2872 }
2873
2874 typedef struct
2875 {
2876 unsigned int i[2];
2877 unsigned int buf[4];
2878 unsigned char in[64];
2879 unsigned char digest[16];
2880 } MD5_CTX;
2881
2882 extern VOID WINAPI MD5Init( MD5_CTX *);
2883 extern VOID WINAPI MD5Update( MD5_CTX *, const unsigned char *, unsigned int );
2884 extern VOID WINAPI MD5Final( MD5_CTX *);
2885
2886 /***********************************************************************
2887 * MsiGetFileHashW [MSI.@]
2888 */
2889 UINT WINAPI MsiGetFileHashW( LPCWSTR szFilePath, DWORD dwOptions,
2890 PMSIFILEHASHINFO pHash )
2891 {
2892 HANDLE handle, mapping;
2893 void *p;
2894 DWORD length;
2895 UINT r = ERROR_FUNCTION_FAILED;
2896
2897 TRACE("%s %08x %p\n", debugstr_w(szFilePath), dwOptions, pHash );
2898
2899 if (!szFilePath)
2900 return ERROR_INVALID_PARAMETER;
2901
2902 if (!*szFilePath)
2903 return ERROR_PATH_NOT_FOUND;
2904
2905 if (dwOptions)
2906 return ERROR_INVALID_PARAMETER;
2907 if (!pHash)
2908 return ERROR_INVALID_PARAMETER;
2909 if (pHash->dwFileHashInfoSize < sizeof *pHash)
2910 return ERROR_INVALID_PARAMETER;
2911
2912 handle = CreateFileW( szFilePath, GENERIC_READ,
2913 FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, NULL );
2914 if (handle == INVALID_HANDLE_VALUE)
2915 return ERROR_FILE_NOT_FOUND;
2916
2917 length = GetFileSize( handle, NULL );
2918
2919 mapping = CreateFileMappingW( handle, NULL, PAGE_READONLY, 0, 0, NULL );
2920 if (mapping)
2921 {
2922 p = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, length );
2923 if (p)
2924 {
2925 MD5_CTX ctx;
2926
2927 MD5Init( &ctx );
2928 MD5Update( &ctx, p, length );
2929 MD5Final( &ctx );
2930 UnmapViewOfFile( p );
2931
2932 memcpy( pHash->dwData, ctx.digest, sizeof pHash->dwData );
2933 r = ERROR_SUCCESS;
2934 }
2935 CloseHandle( mapping );
2936 }
2937 CloseHandle( handle );
2938
2939 return r;
2940 }
2941
2942 /***********************************************************************
2943 * MsiGetFileHashA [MSI.@]
2944 */
2945 UINT WINAPI MsiGetFileHashA( LPCSTR szFilePath, DWORD dwOptions,
2946 PMSIFILEHASHINFO pHash )
2947 {
2948 LPWSTR file;
2949 UINT r;
2950
2951 TRACE("%s %08x %p\n", debugstr_a(szFilePath), dwOptions, pHash );
2952
2953 file = strdupAtoW( szFilePath );
2954 if (szFilePath && !file)
2955 return ERROR_OUTOFMEMORY;
2956
2957 r = MsiGetFileHashW( file, dwOptions, pHash );
2958 msi_free( file );
2959 return r;
2960 }
2961
2962 /***********************************************************************
2963 * MsiAdvertiseScriptW [MSI.@]
2964 */
2965 UINT WINAPI MsiAdvertiseScriptW( LPCWSTR szScriptFile, DWORD dwFlags,
2966 PHKEY phRegData, BOOL fRemoveItems )
2967 {
2968 FIXME("%s %08x %p %d\n",
2969 debugstr_w( szScriptFile ), dwFlags, phRegData, fRemoveItems );
2970 return ERROR_CALL_NOT_IMPLEMENTED;
2971 }
2972
2973 /***********************************************************************
2974 * MsiAdvertiseScriptA [MSI.@]
2975 */
2976 UINT WINAPI MsiAdvertiseScriptA( LPCSTR szScriptFile, DWORD dwFlags,
2977 PHKEY phRegData, BOOL fRemoveItems )
2978 {
2979 FIXME("%s %08x %p %d\n",
2980 debugstr_a( szScriptFile ), dwFlags, phRegData, fRemoveItems );
2981 return ERROR_CALL_NOT_IMPLEMENTED;
2982 }
2983
2984 /***********************************************************************
2985 * MsiIsProductElevatedW [MSI.@]
2986 */
2987 UINT WINAPI MsiIsProductElevatedW( LPCWSTR szProduct, BOOL *pfElevated )
2988 {
2989 FIXME("%s %p - stub\n",
2990 debugstr_w( szProduct ), pfElevated );
2991 *pfElevated = TRUE;
2992 return ERROR_SUCCESS;
2993 }
2994
2995 /***********************************************************************
2996 * MsiIsProductElevatedA [MSI.@]
2997 */
2998 UINT WINAPI MsiIsProductElevatedA( LPCSTR szProduct, BOOL *pfElevated )
2999 {
3000 FIXME("%s %p - stub\n",
3001 debugstr_a( szProduct ), pfElevated );
3002 *pfElevated = TRUE;
3003 return ERROR_SUCCESS;
3004 }
DirectPlay implementation for GSoC