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