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