?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 0.9.39.
[wine/gsoc-2012-control.git] / dlls / msi / msi.c
bloba09984e6e018bcbe168cc6c383ffd876339cbc51
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 || !szProduct[0] || !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 if (!szAttribute[0])
509 {
510 return ERROR_UNKNOWN_PROPERTY;
511 }
512 else
513 {
514 static const WCHAR szDisplayVersion[] = {
515 'D','i','s','p','l','a','y','V','e','r','s','i','o','n',0 };
516
517 FIXME("%s\n", debugstr_w(szAttribute));
518 /* FIXME: some attribute values not tested... */
519
520 if (!lstrcmpW( szAttribute, INSTALLPROPERTY_VERSIONSTRINGW ))
521 szAttribute = szDisplayVersion;
522
523 r = MSIREG_OpenUninstallKey( szProduct, &hkey, FALSE );
524 if (r != ERROR_SUCCESS)
525 return ERROR_UNKNOWN_PRODUCT;
526
527 val = msi_reg_get_val_str( hkey, szAttribute );
528
529 RegCloseKey(hkey);
530 }
531
532 TRACE("returning %s\n", debugstr_w(val));
533
534 if (!val)
535 return ERROR_UNKNOWN_PROPERTY;
536
537 r = msi_strcpy_to_awstring( val, szValue, pcchValueBuf );
538
539 msi_free(val);
540
541 return r;
542 }
543
544 UINT WINAPI MsiGetProductInfoA(LPCSTR szProduct, LPCSTR szAttribute,
545 LPSTR szBuffer, DWORD *pcchValueBuf)
546 {
547 LPWSTR szwProduct, szwAttribute = NULL;
548 UINT r = ERROR_OUTOFMEMORY;
549 awstring buffer;
550
551 TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szAttribute),
552 szBuffer, pcchValueBuf);
553
554 szwProduct = strdupAtoW( szProduct );
555 if( szProduct && !szwProduct )
556 goto end;
557
558 szwAttribute = strdupAtoW( szAttribute );
559 if( szAttribute && !szwAttribute )
560 goto end;
561
562 buffer.unicode = FALSE;
563 buffer.str.a = szBuffer;
564
565 r = MSI_GetProductInfo( szwProduct, szwAttribute,
566 &buffer, pcchValueBuf );
567
568 end:
569 msi_free( szwProduct );
570 msi_free( szwAttribute );
571
572 return r;
573 }
574
575 UINT WINAPI MsiGetProductInfoW(LPCWSTR szProduct, LPCWSTR szAttribute,
576 LPWSTR szBuffer, DWORD *pcchValueBuf)
577 {
578 awstring buffer;
579
580 TRACE("%s %s %p %p\n", debugstr_w(szProduct), debugstr_w(szAttribute),
581 szBuffer, pcchValueBuf);
582
583 buffer.unicode = TRUE;
584 buffer.str.w = szBuffer;
585
586 return MSI_GetProductInfo( szProduct, szAttribute,
587 &buffer, pcchValueBuf );
588 }
589
590 UINT WINAPI MsiEnableLogA(DWORD dwLogMode, LPCSTR szLogFile, DWORD attributes)
591 {
592 LPWSTR szwLogFile = NULL;
593 UINT r;
594
595 TRACE("%08x %s %08x\n", dwLogMode, debugstr_a(szLogFile), attributes);
596
597 if( szLogFile )
598 {
599 szwLogFile = strdupAtoW( szLogFile );
600 if( !szwLogFile )
601 return ERROR_OUTOFMEMORY;
602 }
603 r = MsiEnableLogW( dwLogMode, szwLogFile, attributes );
604 msi_free( szwLogFile );
605 return r;
606 }
607
608 UINT WINAPI MsiEnableLogW(DWORD dwLogMode, LPCWSTR szLogFile, DWORD attributes)
609 {
610 HANDLE file = INVALID_HANDLE_VALUE;
611
612 TRACE("%08x %s %08x\n", dwLogMode, debugstr_w(szLogFile), attributes);
613
614 if (szLogFile)
615 {
616 lstrcpyW(gszLogFile,szLogFile);
617 if (!(attributes & INSTALLLOGATTRIBUTES_APPEND))
618 DeleteFileW(szLogFile);
619 file = CreateFileW(szLogFile, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS,
620 FILE_ATTRIBUTE_NORMAL, NULL);
621 if (file != INVALID_HANDLE_VALUE)
622 CloseHandle(file);
623 else
624 ERR("Unable to enable log %s\n",debugstr_w(szLogFile));
625 }
626 else
627 gszLogFile[0] = '\0';
628
629 return ERROR_SUCCESS;
630 }
631
632 INSTALLSTATE WINAPI MsiQueryProductStateA(LPCSTR szProduct)
633 {
634 LPWSTR szwProduct = NULL;
635 INSTALLSTATE r;
636
637 if( szProduct )
638 {
639 szwProduct = strdupAtoW( szProduct );
640 if( !szwProduct )
641 return ERROR_OUTOFMEMORY;
642 }
643 r = MsiQueryProductStateW( szwProduct );
644 msi_free( szwProduct );
645 return r;
646 }
647
648 INSTALLSTATE WINAPI MsiQueryProductStateW(LPCWSTR szProduct)
649 {
650 UINT rc;
651 INSTALLSTATE rrc = INSTALLSTATE_UNKNOWN;
652 HKEY hkey = 0;
653 static const WCHAR szWindowsInstaller[] = {
654 'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0 };
655 DWORD sz;
656
657 TRACE("%s\n", debugstr_w(szProduct));
658
659 if (!szProduct)
660 return INSTALLSTATE_INVALIDARG;
661
662 rc = MSIREG_OpenUserProductsKey(szProduct,&hkey,FALSE);
663 if (rc != ERROR_SUCCESS)
664 goto end;
665
666 RegCloseKey(hkey);
667
668 rc = MSIREG_OpenUninstallKey(szProduct,&hkey,FALSE);
669 if (rc != ERROR_SUCCESS)
670 goto end;
671
672 sz = sizeof(rrc);
673 rc = RegQueryValueExW(hkey,szWindowsInstaller,NULL,NULL,(LPVOID)&rrc, &sz);
674 if (rc != ERROR_SUCCESS)
675 goto end;
676
677 switch (rrc)
678 {
679 case 1:
680 /* default */
681 rrc = INSTALLSTATE_DEFAULT;
682 break;
683 default:
684 FIXME("Unknown install state read from registry (%i)\n",rrc);
685 rrc = INSTALLSTATE_UNKNOWN;
686 break;
687 }
688 end:
689 RegCloseKey(hkey);
690 return rrc;
691 }
692
693 INSTALLUILEVEL WINAPI MsiSetInternalUI(INSTALLUILEVEL dwUILevel, HWND *phWnd)
694 {
695 INSTALLUILEVEL old = gUILevel;
696 HWND oldwnd = gUIhwnd;
697
698 TRACE("%08x %p\n", dwUILevel, phWnd);
699
700 gUILevel = dwUILevel;
701 if (phWnd)
702 {
703 gUIhwnd = *phWnd;
704 *phWnd = oldwnd;
705 }
706 return old;
707 }
708
709 INSTALLUI_HANDLERA WINAPI MsiSetExternalUIA(INSTALLUI_HANDLERA puiHandler,
710 DWORD dwMessageFilter, LPVOID pvContext)
711 {
712 INSTALLUI_HANDLERA prev = gUIHandlerA;
713
714 TRACE("%p %x %p\n",puiHandler, dwMessageFilter,pvContext);
715 gUIHandlerA = puiHandler;
716 gUIFilter = dwMessageFilter;
717 gUIContext = pvContext;
718
719 return prev;
720 }
721
722 INSTALLUI_HANDLERW WINAPI MsiSetExternalUIW(INSTALLUI_HANDLERW puiHandler,
723 DWORD dwMessageFilter, LPVOID pvContext)
724 {
725 INSTALLUI_HANDLERW prev = gUIHandlerW;
726
727 TRACE("%p %x %p\n",puiHandler,dwMessageFilter,pvContext);
728 gUIHandlerW = puiHandler;
729 gUIFilter = dwMessageFilter;
730 gUIContext = pvContext;
731
732 return prev;
733 }
734
735 /******************************************************************
736 * MsiLoadStringW [MSI.@]
737 *
738 * Loads a string from MSI's string resources.
739 *
740 * PARAMS
741 *
742 * handle [I] only -1 is handled currently
743 * id [I] id of the string to be loaded
744 * lpBuffer [O] buffer for the string to be written to
745 * nBufferMax [I] maximum size of the buffer in characters
746 * lang [I] the preferred language for the string
747 *
748 * RETURNS
749 *
750 * If successful, this function returns the language id of the string loaded
751 * If the function fails, the function returns zero.
752 *
753 * NOTES
754 *
755 * The type of the first parameter is unknown. LoadString's prototype
756 * suggests that it might be a module handle. I have made it an MSI handle
757 * for starters, as -1 is an invalid MSI handle, but not an invalid module
758 * handle. Maybe strings can be stored in an MSI database somehow.
759 */
760 LANGID WINAPI MsiLoadStringW( MSIHANDLE handle, UINT id, LPWSTR lpBuffer,
761 int nBufferMax, LANGID lang )
762 {
763 HRSRC hres;
764 HGLOBAL hResData;
765 LPWSTR p;
766 DWORD i, len;
767
768 TRACE("%ld %u %p %d %d\n", handle, id, lpBuffer, nBufferMax, lang);
769
770 if( handle != -1 )
771 FIXME("don't know how to deal with handle = %08lx\n", handle);
772
773 if( !lang )
774 lang = GetUserDefaultLangID();
775
776 hres = FindResourceExW( msi_hInstance, (LPCWSTR) RT_STRING,
777 (LPWSTR)1, lang );
778 if( !hres )
779 return 0;
780 hResData = LoadResource( msi_hInstance, hres );
781 if( !hResData )
782 return 0;
783 p = LockResource( hResData );
784 if( !p )
785 return 0;
786
787 for (i = 0; i < (id&0xf); i++)
788 p += *p + 1;
789 len = *p;
790
791 if( nBufferMax <= len )
792 return 0;
793
794 memcpy( lpBuffer, p+1, len * sizeof(WCHAR));
795 lpBuffer[ len ] = 0;
796
797 TRACE("found -> %s\n", debugstr_w(lpBuffer));
798
799 return lang;
800 }
801
802 LANGID WINAPI MsiLoadStringA( MSIHANDLE handle, UINT id, LPSTR lpBuffer,
803 int nBufferMax, LANGID lang )
804 {
805 LPWSTR bufW;
806 LANGID r;
807 DWORD len;
808
809 bufW = msi_alloc(nBufferMax*sizeof(WCHAR));
810 r = MsiLoadStringW(handle, id, bufW, nBufferMax, lang);
811 if( r )
812 {
813 len = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL, NULL );
814 if( len <= nBufferMax )
815 WideCharToMultiByte( CP_ACP, 0, bufW, -1,
816 lpBuffer, nBufferMax, NULL, NULL );
817 else
818 r = 0;
819 }
820 msi_free(bufW);
821 return r;
822 }
823
824 INSTALLSTATE WINAPI MsiLocateComponentA(LPCSTR szComponent, LPSTR lpPathBuf,
825 DWORD *pcchBuf)
826 {
827 char szProduct[GUID_SIZE];
828
829 TRACE("%s %p %p\n", debugstr_a(szComponent), lpPathBuf, pcchBuf);
830
831 if (MsiGetProductCodeA( szComponent, szProduct ) != ERROR_SUCCESS)
832 return INSTALLSTATE_UNKNOWN;
833
834 return MsiGetComponentPathA( szProduct, szComponent, lpPathBuf, pcchBuf );
835 }
836
837 INSTALLSTATE WINAPI MsiLocateComponentW(LPCWSTR szComponent, LPWSTR lpPathBuf,
838 DWORD *pcchBuf)
839 {
840 WCHAR szProduct[GUID_SIZE];
841
842 TRACE("%s %p %p\n", debugstr_w(szComponent), lpPathBuf, pcchBuf);
843
844 if (MsiGetProductCodeW( szComponent, szProduct ) != ERROR_SUCCESS)
845 return INSTALLSTATE_UNKNOWN;
846
847 return MsiGetComponentPathW( szProduct, szComponent, lpPathBuf, pcchBuf );
848 }
849
850 UINT WINAPI MsiMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,
851 WORD wLanguageId, DWORD f)
852 {
853 FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_a(lpText), debugstr_a(lpCaption),
854 uType, wLanguageId, f);
855 return MessageBoxExA(hWnd,lpText,lpCaption,uType,wLanguageId);
856 }
857
858 UINT WINAPI MsiMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,
859 WORD wLanguageId, DWORD f)
860 {
861 FIXME("%p %s %s %u %08x %08x\n", hWnd, debugstr_w(lpText), debugstr_w(lpCaption),
862 uType, wLanguageId, f);
863 return MessageBoxExW(hWnd,lpText,lpCaption,uType,wLanguageId);
864 }
865
866 UINT WINAPI MsiProvideAssemblyA( LPCSTR szAssemblyName, LPCSTR szAppContext,
867 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPSTR lpPathBuf,
868 DWORD* pcchPathBuf )
869 {
870 FIXME("%s %s %08x %08x %p %p\n", debugstr_a(szAssemblyName),
871 debugstr_a(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
872 pcchPathBuf);
873 return ERROR_CALL_NOT_IMPLEMENTED;
874 }
875
876 UINT WINAPI MsiProvideAssemblyW( LPCWSTR szAssemblyName, LPCWSTR szAppContext,
877 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPWSTR lpPathBuf,
878 DWORD* pcchPathBuf )
879 {
880 FIXME("%s %s %08x %08x %p %p\n", debugstr_w(szAssemblyName),
881 debugstr_w(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
882 pcchPathBuf);
883 return ERROR_CALL_NOT_IMPLEMENTED;
884 }
885
886 UINT WINAPI MsiProvideComponentFromDescriptorA( LPCSTR szDescriptor,
887 LPSTR szPath, DWORD *pcchPath, DWORD *pcchArgs )
888 {
889 FIXME("%s %p %p %p\n", debugstr_a(szDescriptor), szPath, pcchPath, pcchArgs );
890 return ERROR_CALL_NOT_IMPLEMENTED;
891 }
892
893 UINT WINAPI MsiProvideComponentFromDescriptorW( LPCWSTR szDescriptor,
894 LPWSTR szPath, DWORD *pcchPath, DWORD *pcchArgs )
895 {
896 FIXME("%s %p %p %p\n", debugstr_w(szDescriptor), szPath, pcchPath, pcchArgs );
897 return ERROR_CALL_NOT_IMPLEMENTED;
898 }
899
900 HRESULT WINAPI MsiGetFileSignatureInformationA( LPCSTR szSignedObjectPath,
901 DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, BYTE* pbHashData,
902 DWORD* pcbHashData)
903 {
904 FIXME("%s %08x %p %p %p\n", debugstr_a(szSignedObjectPath), dwFlags,
905 ppcCertContext, pbHashData, pcbHashData);
906 return ERROR_CALL_NOT_IMPLEMENTED;
907 }
908
909 HRESULT WINAPI MsiGetFileSignatureInformationW( LPCWSTR szSignedObjectPath,
910 DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, BYTE* pbHashData,
911 DWORD* pcbHashData)
912 {
913 FIXME("%s %08x %p %p %p\n", debugstr_w(szSignedObjectPath), dwFlags,
914 ppcCertContext, pbHashData, pcbHashData);
915 return ERROR_CALL_NOT_IMPLEMENTED;
916 }
917
918 UINT WINAPI MsiGetProductPropertyA( MSIHANDLE hProduct, LPCSTR szProperty,
919 LPSTR szValue, DWORD *pccbValue )
920 {
921 FIXME("%ld %s %p %p\n", hProduct, debugstr_a(szProperty), szValue, pccbValue);
922 return ERROR_CALL_NOT_IMPLEMENTED;
923 }
924
925 UINT WINAPI MsiGetProductPropertyW( MSIHANDLE hProduct, LPCWSTR szProperty,
926 LPWSTR szValue, DWORD *pccbValue )
927 {
928 FIXME("%ld %s %p %p\n", hProduct, debugstr_w(szProperty), szValue, pccbValue);
929 return ERROR_CALL_NOT_IMPLEMENTED;
930 }
931
932 UINT WINAPI MsiVerifyPackageA( LPCSTR szPackage )
933 {
934 UINT r;
935 LPWSTR szPack = NULL;
936
937 TRACE("%s\n", debugstr_a(szPackage) );
938
939 if( szPackage )
940 {
941 szPack = strdupAtoW( szPackage );
942 if( !szPack )
943 return ERROR_OUTOFMEMORY;
944 }
945
946 r = MsiVerifyPackageW( szPack );
947
948 msi_free( szPack );
949
950 return r;
951 }
952
953 UINT WINAPI MsiVerifyPackageW( LPCWSTR szPackage )
954 {
955 MSIHANDLE handle;
956 UINT r;
957
958 TRACE("%s\n", debugstr_w(szPackage) );
959
960 r = MsiOpenDatabaseW( szPackage, MSIDBOPEN_READONLY, &handle );
961 MsiCloseHandle( handle );
962
963 return r;
964 }
965
966 static INSTALLSTATE WINAPI MSI_GetComponentPath(LPCWSTR szProduct, LPCWSTR szComponent,
967 awstring* lpPathBuf, DWORD* pcchBuf)
968 {
969 WCHAR squished_pc[GUID_SIZE], squished_comp[GUID_SIZE];
970 UINT rc;
971 HKEY hkey = 0;
972 LPWSTR path = NULL;
973 INSTALLSTATE r;
974
975 TRACE("%s %s %p %p\n", debugstr_w(szProduct),
976 debugstr_w(szComponent), lpPathBuf->str.w, pcchBuf);
977
978 if( !szProduct || !szComponent )
979 return INSTALLSTATE_INVALIDARG;
980 if( lpPathBuf->str.w && !pcchBuf )
981 return INSTALLSTATE_INVALIDARG;
982
983 if (!squash_guid( szProduct, squished_pc ) ||
984 !squash_guid( szComponent, squished_comp ))
985 return INSTALLSTATE_INVALIDARG;
986
987 rc = MSIREG_OpenProductsKey( szProduct, &hkey, FALSE);
988 if( rc != ERROR_SUCCESS )
989 return INSTALLSTATE_UNKNOWN;
990
991 RegCloseKey(hkey);
992
993 rc = MSIREG_OpenComponentsKey( szComponent, &hkey, FALSE);
994 if( rc != ERROR_SUCCESS )
995 return INSTALLSTATE_UNKNOWN;
996
997 path = msi_reg_get_val_str( hkey, squished_pc );
998 RegCloseKey(hkey);
999
1000 TRACE("found path of (%s:%s)(%s)\n", debugstr_w(szComponent),
1001 debugstr_w(szProduct), debugstr_w(path));
1002
1003 if (!path)
1004 return INSTALLSTATE_UNKNOWN;
1005
1006 if (path[0])
1007 r = INSTALLSTATE_LOCAL;
1008 else
1009 r = INSTALLSTATE_NOTUSED;
1010
1011 msi_strcpy_to_awstring( path, lpPathBuf, pcchBuf );
1012
1013 msi_free( path );
1014 return r;
1015 }
1016
1017 /******************************************************************
1018 * MsiGetComponentPathW [MSI.@]
1019 */
1020 INSTALLSTATE WINAPI MsiGetComponentPathW(LPCWSTR szProduct, LPCWSTR szComponent,
1021 LPWSTR lpPathBuf, DWORD* pcchBuf)
1022 {
1023 awstring path;
1024
1025 path.unicode = TRUE;
1026 path.str.w = lpPathBuf;
1027
1028 return MSI_GetComponentPath( szProduct, szComponent, &path, pcchBuf );
1029 }
1030
1031 /******************************************************************
1032 * MsiGetComponentPathA [MSI.@]
1033 */
1034 INSTALLSTATE WINAPI MsiGetComponentPathA(LPCSTR szProduct, LPCSTR szComponent,
1035 LPSTR lpPathBuf, DWORD* pcchBuf)
1036 {
1037 LPWSTR szwProduct, szwComponent = NULL;
1038 INSTALLSTATE r = INSTALLSTATE_UNKNOWN;
1039 awstring path;
1040
1041 szwProduct = strdupAtoW( szProduct );
1042 if( szProduct && !szwProduct)
1043 goto end;
1044
1045 szwComponent = strdupAtoW( szComponent );
1046 if( szComponent && !szwComponent )
1047 goto end;
1048
1049 path.unicode = FALSE;
1050 path.str.a = lpPathBuf;
1051
1052 r = MSI_GetComponentPath( szwProduct, szwComponent, &path, pcchBuf );
1053
1054 end:
1055 msi_free( szwProduct );
1056 msi_free( szwComponent );
1057
1058 return r;
1059 }
1060
1061 /******************************************************************
1062 * MsiQueryFeatureStateA [MSI.@]
1063 */
1064 INSTALLSTATE WINAPI MsiQueryFeatureStateA(LPCSTR szProduct, LPCSTR szFeature)
1065 {
1066 LPWSTR szwProduct = NULL, szwFeature= NULL;
1067 INSTALLSTATE rc = INSTALLSTATE_UNKNOWN;
1068
1069 szwProduct = strdupAtoW( szProduct );
1070 if ( szProduct && !szwProduct )
1071 goto end;
1072
1073 szwFeature = strdupAtoW( szFeature );
1074 if ( szFeature && !szwFeature )
1075 goto end;
1076
1077 rc = MsiQueryFeatureStateW(szwProduct, szwFeature);
1078
1079 end:
1080 msi_free( szwProduct);
1081 msi_free( szwFeature);
1082
1083 return rc;
1084 }
1085
1086 /******************************************************************
1087 * MsiQueryFeatureStateW [MSI.@]
1088 *
1089 * Checks the state of a feature
1090 *
1091 * PARAMS
1092 * szProduct [I] Product's GUID string
1093 * szFeature [I] Feature's GUID string
1094 *
1095 * RETURNS
1096 * INSTALLSTATE_LOCAL Feature is installed and useable
1097 * INSTALLSTATE_ABSENT Feature is absent
1098 * INSTALLSTATE_ADVERTISED Feature should be installed on demand
1099 * INSTALLSTATE_UNKNOWN An error occurred
1100 * INSTALLSTATE_INVALIDARG One of the GUIDs was invalid
1101 *
1102 */
1103 INSTALLSTATE WINAPI MsiQueryFeatureStateW(LPCWSTR szProduct, LPCWSTR szFeature)
1104 {
1105 WCHAR squishProduct[33], comp[GUID_SIZE];
1106 GUID guid;
1107 LPWSTR components, p, parent_feature;
1108 UINT rc;
1109 HKEY hkey;
1110 INSTALLSTATE r;
1111 BOOL missing = FALSE;
1112
1113 TRACE("%s %s\n", debugstr_w(szProduct), debugstr_w(szFeature));
1114
1115 if (!szProduct || !szFeature)
1116 return INSTALLSTATE_INVALIDARG;
1117
1118 if (!squash_guid( szProduct, squishProduct ))
1119 return INSTALLSTATE_INVALIDARG;
1120
1121 /* check that it's installed at all */
1122 rc = MSIREG_OpenUserFeaturesKey(szProduct, &hkey, FALSE);
1123 if (rc != ERROR_SUCCESS)
1124 return INSTALLSTATE_UNKNOWN;
1125
1126 parent_feature = msi_reg_get_val_str( hkey, szFeature );
1127 RegCloseKey(hkey);
1128
1129 if (!parent_feature)
1130 return INSTALLSTATE_UNKNOWN;
1131
1132 r = (parent_feature[0] == 6) ? INSTALLSTATE_ABSENT : INSTALLSTATE_LOCAL;
1133 msi_free(parent_feature);
1134 if (r == INSTALLSTATE_ABSENT)
1135 return r;
1136
1137 /* now check if it's complete or advertised */
1138 rc = MSIREG_OpenFeaturesKey(szProduct, &hkey, FALSE);
1139 if (rc != ERROR_SUCCESS)
1140 return INSTALLSTATE_UNKNOWN;
1141
1142 components = msi_reg_get_val_str( hkey, szFeature );
1143 RegCloseKey(hkey);
1144
1145 TRACE("rc = %d buffer = %s\n", rc, debugstr_w(components));
1146
1147 if (!components)
1148 {
1149 ERR("components missing %s %s\n",
1150 debugstr_w(szProduct), debugstr_w(szFeature));
1151 return INSTALLSTATE_UNKNOWN;
1152 }
1153
1154 for( p = components; *p != 2 ; p += 20)
1155 {
1156 if (!decode_base85_guid( p, &guid ))
1157 {
1158 ERR("%s\n", debugstr_w(p));
1159 break;
1160 }
1161 StringFromGUID2(&guid, comp, GUID_SIZE);
1162 r = MsiGetComponentPathW(szProduct, comp, NULL, 0);
1163 TRACE("component %s state %d\n", debugstr_guid(&guid), r);
1164 switch (r)
1165 {
1166 case INSTALLSTATE_NOTUSED:
1167 case INSTALLSTATE_LOCAL:
1168 case INSTALLSTATE_SOURCE:
1169 break;
1170 default:
1171 missing = TRUE;
1172 }
1173 }
1174
1175 TRACE("%s %s -> %d\n", debugstr_w(szProduct), debugstr_w(szFeature), r);
1176 msi_free(components);
1177
1178 if (missing)
1179 return INSTALLSTATE_ADVERTISED;
1180
1181 return INSTALLSTATE_LOCAL;
1182 }
1183
1184 /******************************************************************
1185 * MsiGetFileVersionA [MSI.@]
1186 */
1187 UINT WINAPI MsiGetFileVersionA(LPCSTR szFilePath, LPSTR lpVersionBuf,
1188 DWORD* pcchVersionBuf, LPSTR lpLangBuf, DWORD* pcchLangBuf)
1189 {
1190 LPWSTR szwFilePath = NULL, lpwVersionBuff = NULL, lpwLangBuff = NULL;
1191 UINT ret = ERROR_OUTOFMEMORY;
1192
1193 if( szFilePath )
1194 {
1195 szwFilePath = strdupAtoW( szFilePath );
1196 if( !szwFilePath )
1197 goto end;
1198 }
1199
1200 if( lpVersionBuf && pcchVersionBuf && *pcchVersionBuf )
1201 {
1202 lpwVersionBuff = msi_alloc(*pcchVersionBuf*sizeof(WCHAR));
1203 if( !lpwVersionBuff )
1204 goto end;
1205 }
1206
1207 if( lpLangBuf && pcchLangBuf && *pcchLangBuf )
1208 {
1209 lpwLangBuff = msi_alloc(*pcchLangBuf*sizeof(WCHAR));
1210 if( !lpwLangBuff )
1211 goto end;
1212 }
1213
1214 ret = MsiGetFileVersionW(szwFilePath, lpwVersionBuff, pcchVersionBuf,
1215 lpwLangBuff, pcchLangBuf);
1216
1217 if( lpwVersionBuff )
1218 WideCharToMultiByte(CP_ACP, 0, lpwVersionBuff, -1,
1219 lpVersionBuf, *pcchVersionBuf, NULL, NULL);
1220 if( lpwLangBuff )
1221 WideCharToMultiByte(CP_ACP, 0, lpwLangBuff, -1,
1222 lpLangBuf, *pcchLangBuf, NULL, NULL);
1223
1224 end:
1225 msi_free(szwFilePath);
1226 msi_free(lpwVersionBuff);
1227 msi_free(lpwLangBuff);
1228
1229 return ret;
1230 }
1231
1232 /******************************************************************
1233 * MsiGetFileVersionW [MSI.@]
1234 */
1235 UINT WINAPI MsiGetFileVersionW(LPCWSTR szFilePath, LPWSTR lpVersionBuf,
1236 DWORD* pcchVersionBuf, LPWSTR lpLangBuf, DWORD* pcchLangBuf)
1237 {
1238 static const WCHAR szVersionResource[] = {'\\',0};
1239 static const WCHAR szVersionFormat[] = {
1240 '%','d','.','%','d','.','%','d','.','%','d',0};
1241 static const WCHAR szLangFormat[] = {'%','d',0};
1242 UINT ret = 0;
1243 DWORD dwVerLen;
1244 LPVOID lpVer = NULL;
1245 VS_FIXEDFILEINFO *ffi;
1246 UINT puLen;
1247 WCHAR tmp[32];
1248
1249 TRACE("%s %p %d %p %d\n", debugstr_w(szFilePath),
1250 lpVersionBuf, pcchVersionBuf?*pcchVersionBuf:0,
1251 lpLangBuf, pcchLangBuf?*pcchLangBuf:0);
1252
1253 dwVerLen = GetFileVersionInfoSizeW(szFilePath, NULL);
1254 if( !dwVerLen )
1255 return GetLastError();
1256
1257 lpVer = msi_alloc(dwVerLen);
1258 if( !lpVer )
1259 {
1260 ret = ERROR_OUTOFMEMORY;
1261 goto end;
1262 }
1263
1264 if( !GetFileVersionInfoW(szFilePath, 0, dwVerLen, lpVer) )
1265 {
1266 ret = GetLastError();
1267 goto end;
1268 }
1269 if( lpVersionBuf && pcchVersionBuf && *pcchVersionBuf )
1270 {
1271 if( VerQueryValueW(lpVer, szVersionResource, (LPVOID*)&ffi, &puLen) &&
1272 (puLen > 0) )
1273 {
1274 wsprintfW(tmp, szVersionFormat,
1275 HIWORD(ffi->dwFileVersionMS), LOWORD(ffi->dwFileVersionMS),
1276 HIWORD(ffi->dwFileVersionLS), LOWORD(ffi->dwFileVersionLS));
1277 lstrcpynW(lpVersionBuf, tmp, *pcchVersionBuf);
1278 *pcchVersionBuf = lstrlenW(lpVersionBuf);
1279 }
1280 else
1281 {
1282 *lpVersionBuf = 0;
1283 *pcchVersionBuf = 0;
1284 }
1285 }
1286
1287 if( lpLangBuf && pcchLangBuf && *pcchLangBuf )
1288 {
1289 DWORD lang = GetUserDefaultLangID();
1290
1291 FIXME("Retrieve language from file\n");
1292 wsprintfW(tmp, szLangFormat, lang);
1293 lstrcpynW(lpLangBuf, tmp, *pcchLangBuf);
1294 *pcchLangBuf = lstrlenW(lpLangBuf);
1295 }
1296
1297 end:
1298 msi_free(lpVer);
1299 return ret;
1300 }
1301
1302 /***********************************************************************
1303 * MsiGetFeatureUsageW [MSI.@]
1304 */
1305 UINT WINAPI MsiGetFeatureUsageW( LPCWSTR szProduct, LPCWSTR szFeature,
1306 DWORD* pdwUseCount, WORD* pwDateUsed )
1307 {
1308 FIXME("%s %s %p %p\n",debugstr_w(szProduct), debugstr_w(szFeature),
1309 pdwUseCount, pwDateUsed);
1310 return ERROR_CALL_NOT_IMPLEMENTED;
1311 }
1312
1313 /***********************************************************************
1314 * MsiGetFeatureUsageA [MSI.@]
1315 */
1316 UINT WINAPI MsiGetFeatureUsageA( LPCSTR szProduct, LPCSTR szFeature,
1317 DWORD* pdwUseCount, WORD* pwDateUsed )
1318 {
1319 LPWSTR prod = NULL, feat = NULL;
1320 UINT ret = ERROR_OUTOFMEMORY;
1321
1322 TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szFeature),
1323 pdwUseCount, pwDateUsed);
1324
1325 prod = strdupAtoW( szProduct );
1326 if (szProduct && !prod)
1327 goto end;
1328
1329 feat = strdupAtoW( szFeature );
1330 if (szFeature && !feat)
1331 goto end;
1332
1333 ret = MsiGetFeatureUsageW( prod, feat, pdwUseCount, pwDateUsed );
1334
1335 end:
1336 msi_free( prod );
1337 msi_free( feat );
1338
1339 return ret;
1340 }
1341
1342 /***********************************************************************
1343 * MsiUseFeatureExW [MSI.@]
1344 */
1345 INSTALLSTATE WINAPI MsiUseFeatureExW( LPCWSTR szProduct, LPCWSTR szFeature,
1346 DWORD dwInstallMode, DWORD dwReserved )
1347 {
1348 INSTALLSTATE state;
1349
1350 TRACE("%s %s %i %i\n", debugstr_w(szProduct), debugstr_w(szFeature),
1351 dwInstallMode, dwReserved);
1352
1353 state = MsiQueryFeatureStateW( szProduct, szFeature );
1354
1355 if (dwReserved)
1356 return INSTALLSTATE_INVALIDARG;
1357
1358 if (state == INSTALLSTATE_LOCAL && dwInstallMode != INSTALLMODE_NODETECTION)
1359 {
1360 FIXME("mark product %s feature %s as used\n",
1361 debugstr_w(szProduct), debugstr_w(szFeature) );
1362 }
1363
1364 return state;
1365 }
1366
1367 /***********************************************************************
1368 * MsiUseFeatureExA [MSI.@]
1369 */
1370 INSTALLSTATE WINAPI MsiUseFeatureExA( LPCSTR szProduct, LPCSTR szFeature,
1371 DWORD dwInstallMode, DWORD dwReserved )
1372 {
1373 INSTALLSTATE ret = INSTALLSTATE_UNKNOWN;
1374 LPWSTR prod = NULL, feat = NULL;
1375
1376 TRACE("%s %s %i %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
1377 dwInstallMode, dwReserved);
1378
1379 prod = strdupAtoW( szProduct );
1380 if (szProduct && !prod)
1381 goto end;
1382
1383 feat = strdupAtoW( szFeature );
1384 if (szFeature && !feat)
1385 goto end;
1386
1387 ret = MsiUseFeatureExW( prod, feat, dwInstallMode, dwReserved );
1388
1389 end:
1390 msi_free( prod );
1391 msi_free( feat );
1392
1393 return ret;
1394 }
1395
1396 /***********************************************************************
1397 * MsiUseFeatureW [MSI.@]
1398 */
1399 INSTALLSTATE WINAPI MsiUseFeatureW( LPCWSTR szProduct, LPCWSTR szFeature )
1400 {
1401 return MsiUseFeatureExW(szProduct, szFeature, 0, 0);
1402 }
1403
1404 /***********************************************************************
1405 * MsiUseFeatureA [MSI.@]
1406 */
1407 INSTALLSTATE WINAPI MsiUseFeatureA( LPCSTR szProduct, LPCSTR szFeature )
1408 {
1409 return MsiUseFeatureExA(szProduct, szFeature, 0, 0);
1410 }
1411
1412 /***********************************************************************
1413 * MSI_ProvideQualifiedComponentEx [internal]
1414 */
1415 static UINT WINAPI MSI_ProvideQualifiedComponentEx(LPCWSTR szComponent,
1416 LPCWSTR szQualifier, DWORD dwInstallMode, LPCWSTR szProduct,
1417 DWORD Unused1, DWORD Unused2, awstring *lpPathBuf,
1418 DWORD* pcchPathBuf)
1419 {
1420 WCHAR product[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1],
1421 feature[MAX_FEATURE_CHARS+1];
1422 LPWSTR info;
1423 HKEY hkey;
1424 DWORD sz;
1425 UINT rc;
1426
1427 TRACE("%s %s %i %s %i %i %p %p\n", debugstr_w(szComponent),
1428 debugstr_w(szQualifier), dwInstallMode, debugstr_w(szProduct),
1429 Unused1, Unused2, lpPathBuf, pcchPathBuf);
1430
1431 rc = MSIREG_OpenUserComponentsKey(szComponent, &hkey, FALSE);
1432 if (rc != ERROR_SUCCESS)
1433 return ERROR_INDEX_ABSENT;
1434
1435 info = msi_reg_get_val_str( hkey, szQualifier );
1436 RegCloseKey(hkey);
1437
1438 if (!info)
1439 return ERROR_INDEX_ABSENT;
1440
1441 MsiDecomposeDescriptorW(info, product, feature, component, &sz);
1442
1443 if (!szProduct)
1444 rc = MSI_GetComponentPath(product, component, lpPathBuf, pcchPathBuf);
1445 else
1446 rc = MSI_GetComponentPath(szProduct, component, lpPathBuf, pcchPathBuf);
1447
1448 msi_free( info );
1449
1450 if (rc != INSTALLSTATE_LOCAL)
1451 return ERROR_FILE_NOT_FOUND;
1452
1453 return ERROR_SUCCESS;
1454 }
1455
1456 /***********************************************************************
1457 * MsiProvideQualifiedComponentExW [MSI.@]
1458 */
1459 UINT WINAPI MsiProvideQualifiedComponentExW(LPCWSTR szComponent,
1460 LPCWSTR szQualifier, DWORD dwInstallMode, LPWSTR szProduct,
1461 DWORD Unused1, DWORD Unused2, LPWSTR lpPathBuf,
1462 DWORD* pcchPathBuf)
1463 {
1464 awstring path;
1465
1466 path.unicode = TRUE;
1467 path.str.w = lpPathBuf;
1468
1469 return MSI_ProvideQualifiedComponentEx(szComponent, szQualifier,
1470 dwInstallMode, szProduct, Unused1, Unused2, &path, pcchPathBuf);
1471 }
1472
1473 /***********************************************************************
1474 * MsiProvideQualifiedComponentExA [MSI.@]
1475 */
1476 UINT WINAPI MsiProvideQualifiedComponentExA(LPCSTR szComponent,
1477 LPCSTR szQualifier, DWORD dwInstallMode, LPSTR szProduct,
1478 DWORD Unused1, DWORD Unused2, LPSTR lpPathBuf,
1479 DWORD* pcchPathBuf)
1480 {
1481 LPWSTR szwComponent, szwQualifier = NULL, szwProduct = NULL;
1482 UINT r = ERROR_OUTOFMEMORY;
1483 awstring path;
1484
1485 TRACE("%s %s %u %s %u %u %p %p\n", debugstr_a(szComponent),
1486 debugstr_a(szQualifier), dwInstallMode, debugstr_a(szProduct),
1487 Unused1, Unused2, lpPathBuf, pcchPathBuf);
1488
1489 szwComponent = strdupAtoW( szComponent );
1490 if (szComponent && !szwComponent)
1491 goto end;
1492
1493 szwQualifier = strdupAtoW( szQualifier );
1494 if (szQualifier && !szwQualifier)
1495 goto end;
1496
1497 szwProduct = strdupAtoW( szProduct );
1498 if (szProduct && !szwProduct)
1499 goto end;
1500
1501 path.unicode = FALSE;
1502 path.str.a = lpPathBuf;
1503
1504 r = MSI_ProvideQualifiedComponentEx(szwComponent, szwQualifier,
1505 dwInstallMode, szwProduct, Unused1,
1506 Unused2, &path, pcchPathBuf);
1507 end:
1508 msi_free(szwProduct);
1509 msi_free(szwComponent);
1510 msi_free(szwQualifier);
1511
1512 return r;
1513 }
1514
1515 /***********************************************************************
1516 * MsiProvideQualifiedComponentW [MSI.@]
1517 */
1518 UINT WINAPI MsiProvideQualifiedComponentW( LPCWSTR szComponent,
1519 LPCWSTR szQualifier, DWORD dwInstallMode, LPWSTR lpPathBuf,
1520 DWORD* pcchPathBuf)
1521 {
1522 return MsiProvideQualifiedComponentExW(szComponent, szQualifier,
1523 dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
1524 }
1525
1526 /***********************************************************************
1527 * MsiProvideQualifiedComponentA [MSI.@]
1528 */
1529 UINT WINAPI MsiProvideQualifiedComponentA( LPCSTR szComponent,
1530 LPCSTR szQualifier, DWORD dwInstallMode, LPSTR lpPathBuf,
1531 DWORD* pcchPathBuf)
1532 {
1533 return MsiProvideQualifiedComponentExA(szComponent, szQualifier,
1534 dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
1535 }
1536
1537 /***********************************************************************
1538 * MSI_GetUserInfo [internal]
1539 */
1540 static USERINFOSTATE WINAPI MSI_GetUserInfo(LPCWSTR szProduct,
1541 awstring *lpUserNameBuf, DWORD* pcchUserNameBuf,
1542 awstring *lpOrgNameBuf, DWORD* pcchOrgNameBuf,
1543 awstring *lpSerialBuf, DWORD* pcchSerialBuf)
1544 {
1545 HKEY hkey;
1546 LPWSTR user, org, serial;
1547 UINT r;
1548 USERINFOSTATE state;
1549
1550 TRACE("%s %p %p %p %p %p %p\n",debugstr_w(szProduct), lpUserNameBuf,
1551 pcchUserNameBuf, lpOrgNameBuf, pcchOrgNameBuf, lpSerialBuf,
1552 pcchSerialBuf);
1553
1554 if (!szProduct)
1555 return USERINFOSTATE_INVALIDARG;
1556
1557 r = MSIREG_OpenUninstallKey(szProduct, &hkey, FALSE);
1558 if (r != ERROR_SUCCESS)
1559 return USERINFOSTATE_UNKNOWN;
1560
1561 user = msi_reg_get_val_str( hkey, INSTALLPROPERTY_REGOWNERW );
1562 org = msi_reg_get_val_str( hkey, INSTALLPROPERTY_REGCOMPANYW );
1563 serial = msi_reg_get_val_str( hkey, INSTALLPROPERTY_PRODUCTIDW );
1564
1565 RegCloseKey(hkey);
1566
1567 state = USERINFOSTATE_PRESENT;
1568
1569 if (user)
1570 {
1571 r = msi_strcpy_to_awstring( user, lpUserNameBuf, pcchUserNameBuf );
1572 if (r == ERROR_MORE_DATA)
1573 state = USERINFOSTATE_MOREDATA;
1574 }
1575 else
1576 state = USERINFOSTATE_ABSENT;
1577 if (org)
1578 {
1579 r = msi_strcpy_to_awstring( org, lpOrgNameBuf, pcchOrgNameBuf );
1580 if (r == ERROR_MORE_DATA && state == USERINFOSTATE_PRESENT)
1581 state = USERINFOSTATE_MOREDATA;
1582 }
1583 /* msdn states: The user information is considered to be present even in the absence of a company name. */
1584 if (serial)
1585 {
1586 r = msi_strcpy_to_awstring( serial, lpSerialBuf, pcchSerialBuf );
1587 if (r == ERROR_MORE_DATA && state == USERINFOSTATE_PRESENT)
1588 state = USERINFOSTATE_MOREDATA;
1589 }
1590 else
1591 state = USERINFOSTATE_ABSENT;
1592
1593 msi_free( user );
1594 msi_free( org );
1595 msi_free( serial );
1596
1597 return state;
1598 }
1599
1600 /***********************************************************************
1601 * MsiGetUserInfoW [MSI.@]
1602 */
1603 USERINFOSTATE WINAPI MsiGetUserInfoW(LPCWSTR szProduct,
1604 LPWSTR lpUserNameBuf, DWORD* pcchUserNameBuf,
1605 LPWSTR lpOrgNameBuf, DWORD* pcchOrgNameBuf,
1606 LPWSTR lpSerialBuf, DWORD* pcchSerialBuf)
1607 {
1608 awstring user, org, serial;
1609
1610 user.unicode = TRUE;
1611 user.str.w = lpUserNameBuf;
1612 org.unicode = TRUE;
1613 org.str.w = lpOrgNameBuf;
1614 serial.unicode = TRUE;
1615 serial.str.w = lpSerialBuf;
1616
1617 return MSI_GetUserInfo( szProduct, &user, pcchUserNameBuf,
1618 &org, pcchOrgNameBuf,
1619 &serial, pcchSerialBuf );
1620 }
1621
1622 USERINFOSTATE WINAPI MsiGetUserInfoA(LPCSTR szProduct,
1623 LPSTR lpUserNameBuf, DWORD* pcchUserNameBuf,
1624 LPSTR lpOrgNameBuf, DWORD* pcchOrgNameBuf,
1625 LPSTR lpSerialBuf, DWORD* pcchSerialBuf)
1626 {
1627 awstring user, org, serial;
1628 LPWSTR prod;
1629 UINT r;
1630
1631 prod = strdupAtoW( szProduct );
1632 if (szProduct && !prod)
1633 return ERROR_OUTOFMEMORY;
1634
1635 user.unicode = FALSE;
1636 user.str.a = lpUserNameBuf;
1637 org.unicode = FALSE;
1638 org.str.a = lpOrgNameBuf;
1639 serial.unicode = FALSE;
1640 serial.str.a = lpSerialBuf;
1641
1642 r = MSI_GetUserInfo( prod, &user, pcchUserNameBuf,
1643 &org, pcchOrgNameBuf,
1644 &serial, pcchSerialBuf );
1645
1646 msi_free( prod );
1647
1648 return r;
1649 }
1650
1651 UINT WINAPI MsiCollectUserInfoW(LPCWSTR szProduct)
1652 {
1653 MSIHANDLE handle;
1654 UINT rc;
1655 MSIPACKAGE *package;
1656 static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
1657
1658 TRACE("(%s)\n",debugstr_w(szProduct));
1659
1660 rc = MsiOpenProductW(szProduct,&handle);
1661 if (rc != ERROR_SUCCESS)
1662 return ERROR_INVALID_PARAMETER;
1663
1664 package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
1665 rc = ACTION_PerformUIAction(package, szFirstRun);
1666 msiobj_release( &package->hdr );
1667
1668 MsiCloseHandle(handle);
1669
1670 return rc;
1671 }
1672
1673 UINT WINAPI MsiCollectUserInfoA(LPCSTR szProduct)
1674 {
1675 MSIHANDLE handle;
1676 UINT rc;
1677 MSIPACKAGE *package;
1678 static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
1679
1680 TRACE("(%s)\n",debugstr_a(szProduct));
1681
1682 rc = MsiOpenProductA(szProduct,&handle);
1683 if (rc != ERROR_SUCCESS)
1684 return ERROR_INVALID_PARAMETER;
1685
1686 package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
1687 rc = ACTION_PerformUIAction(package, szFirstRun);
1688 msiobj_release( &package->hdr );
1689
1690 MsiCloseHandle(handle);
1691
1692 return rc;
1693 }
1694
1695 /***********************************************************************
1696 * MsiConfigureFeatureA [MSI.@]
1697 */
1698 UINT WINAPI MsiConfigureFeatureA(LPCSTR szProduct, LPCSTR szFeature, INSTALLSTATE eInstallState)
1699 {
1700 LPWSTR prod, feat = NULL;
1701 UINT r = ERROR_OUTOFMEMORY;
1702
1703 TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature), eInstallState);
1704
1705 prod = strdupAtoW( szProduct );
1706 if (szProduct && !prod)
1707 goto end;
1708
1709 feat = strdupAtoW( szFeature );
1710 if (szFeature && !feat)
1711 goto end;
1712
1713 r = MsiConfigureFeatureW(prod, feat, eInstallState);
1714
1715 end:
1716 msi_free(feat);
1717 msi_free(prod);
1718
1719 return r;
1720 }
1721
1722 /***********************************************************************
1723 * MsiConfigureFeatureW [MSI.@]
1724 */
1725 UINT WINAPI MsiConfigureFeatureW(LPCWSTR szProduct, LPCWSTR szFeature, INSTALLSTATE eInstallState)
1726 {
1727 static const WCHAR szCostInit[] = { 'C','o','s','t','I','n','i','t','i','a','l','i','z','e',0 };
1728 MSIPACKAGE *package = NULL;
1729 UINT r;
1730 WCHAR sourcepath[MAX_PATH], filename[MAX_PATH];
1731 DWORD sz;
1732
1733 TRACE("%s %s %i\n", debugstr_w(szProduct), debugstr_w(szFeature), eInstallState);
1734
1735 if (!szProduct || !szFeature)
1736 return ERROR_INVALID_PARAMETER;
1737
1738 switch (eInstallState)
1739 {
1740 case INSTALLSTATE_DEFAULT:
1741 /* FIXME: how do we figure out the default location? */
1742 eInstallState = INSTALLSTATE_LOCAL;
1743 break;
1744 case INSTALLSTATE_LOCAL:
1745 case INSTALLSTATE_SOURCE:
1746 case INSTALLSTATE_ABSENT:
1747 case INSTALLSTATE_ADVERTISED:
1748 break;
1749 default:
1750 return ERROR_INVALID_PARAMETER;
1751 }
1752
1753 r = MSI_OpenProductW( szProduct, &package );
1754 if (r != ERROR_SUCCESS)
1755 return r;
1756
1757 sz = sizeof(sourcepath);
1758 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
1759 MSICODE_PRODUCT, INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
1760
1761 sz = sizeof(filename);
1762 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
1763 MSICODE_PRODUCT, INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
1764
1765 lstrcatW( sourcepath, filename );
1766
1767 MsiSetInternalUI( INSTALLUILEVEL_BASIC, NULL );
1768
1769 r = ACTION_PerformUIAction( package, szCostInit );
1770 if (r != ERROR_SUCCESS)
1771 goto end;
1772
1773 r = MSI_SetFeatureStateW( package, szFeature, eInstallState);
1774 if (r != ERROR_SUCCESS)
1775 goto end;
1776
1777 r = MSI_InstallPackage( package, sourcepath, NULL );
1778
1779 end:
1780 msiobj_release( &package->hdr );
1781
1782 return r;
1783 }
1784
1785 /***********************************************************************
1786 * MsiCreateAndVerifyInstallerDirectory [MSI.@]
1787 *
1788 * Notes: undocumented
1789 */
1790 UINT WINAPI MsiCreateAndVerifyInstallerDirectory(DWORD dwReserved)
1791 {
1792 WCHAR path[MAX_PATH];
1793
1794 TRACE("%d\n", dwReserved);
1795
1796 if (dwReserved)
1797 {
1798 FIXME("dwReserved=%d\n", dwReserved);
1799 return ERROR_INVALID_PARAMETER;
1800 }
1801
1802 if (!GetWindowsDirectoryW(path, MAX_PATH))
1803 return ERROR_FUNCTION_FAILED;
1804
1805 lstrcatW(path, installerW);
1806
1807 if (!CreateDirectoryW(path, NULL))
1808 return ERROR_FUNCTION_FAILED;
1809
1810 return ERROR_SUCCESS;
1811 }
1812
1813 /***********************************************************************
1814 * MsiGetShortcutTargetA [MSI.@]
1815 */
1816 UINT WINAPI MsiGetShortcutTargetA( LPCSTR szShortcutTarget,
1817 LPSTR szProductCode, LPSTR szFeatureId,
1818 LPSTR szComponentCode )
1819 {
1820 LPWSTR target;
1821 const int len = MAX_FEATURE_CHARS+1;
1822 WCHAR product[MAX_FEATURE_CHARS+1], feature[MAX_FEATURE_CHARS+1], component[MAX_FEATURE_CHARS+1];
1823 UINT r;
1824
1825 target = strdupAtoW( szShortcutTarget );
1826 if (szShortcutTarget && !target )
1827 return ERROR_OUTOFMEMORY;
1828 product[0] = 0;
1829 feature[0] = 0;
1830 component[0] = 0;
1831 r = MsiGetShortcutTargetW( target, product, feature, component );
1832 msi_free( target );
1833 if (r == ERROR_SUCCESS)
1834 {
1835 WideCharToMultiByte( CP_ACP, 0, product, -1, szProductCode, len, NULL, NULL );
1836 WideCharToMultiByte( CP_ACP, 0, feature, -1, szFeatureId, len, NULL, NULL );
1837 WideCharToMultiByte( CP_ACP, 0, component, -1, szComponentCode, len, NULL, NULL );
1838 }
1839 return r;
1840 }
1841
1842 /***********************************************************************
1843 * MsiGetShortcutTargetW [MSI.@]
1844 */
1845 UINT WINAPI MsiGetShortcutTargetW( LPCWSTR szShortcutTarget,
1846 LPWSTR szProductCode, LPWSTR szFeatureId,
1847 LPWSTR szComponentCode )
1848 {
1849 IShellLinkDataList *dl = NULL;
1850 IPersistFile *pf = NULL;
1851 LPEXP_DARWIN_LINK darwin = NULL;
1852 HRESULT r, init;
1853
1854 TRACE("%s %p %p %p\n", debugstr_w(szShortcutTarget),
1855 szProductCode, szFeatureId, szComponentCode );
1856
1857 init = CoInitialize(NULL);
1858
1859 r = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
1860 &IID_IPersistFile, (LPVOID*) &pf );
1861 if( SUCCEEDED( r ) )
1862 {
1863 r = IPersistFile_Load( pf, szShortcutTarget,
1864 STGM_READ | STGM_SHARE_DENY_WRITE );
1865 if( SUCCEEDED( r ) )
1866 {
1867 r = IPersistFile_QueryInterface( pf, &IID_IShellLinkDataList,
1868 (LPVOID*) &dl );
1869 if( SUCCEEDED( r ) )
1870 {
1871 IShellLinkDataList_CopyDataBlock( dl, EXP_DARWIN_ID_SIG,
1872 (LPVOID) &darwin );
1873 IShellLinkDataList_Release( dl );
1874 }
1875 }
1876 IPersistFile_Release( pf );
1877 }
1878
1879 if (SUCCEEDED(init))
1880 CoUninitialize();
1881
1882 TRACE("darwin = %p\n", darwin);
1883
1884 if (darwin)
1885 {
1886 DWORD sz;
1887 UINT ret;
1888
1889 ret = MsiDecomposeDescriptorW( darwin->szwDarwinID,
1890 szProductCode, szFeatureId, szComponentCode, &sz );
1891 LocalFree( darwin );
1892 return ret;
1893 }
1894
1895 return ERROR_FUNCTION_FAILED;
1896 }
1897
1898 UINT WINAPI MsiReinstallFeatureW( LPCWSTR szProduct, LPCWSTR szFeature,
1899 DWORD dwReinstallMode )
1900 {
1901 MSIPACKAGE* package = NULL;
1902 UINT r;
1903 WCHAR sourcepath[MAX_PATH];
1904 WCHAR filename[MAX_PATH];
1905 static const WCHAR szLogVerbose[] = {
1906 ' ','L','O','G','V','E','R','B','O','S','E',0 };
1907 static const WCHAR szInstalled[] = { 'I','n','s','t','a','l','l','e','d',0};
1908 static const WCHAR szReinstall[] = {'R','E','I','N','S','T','A','L','L',0};
1909 static const WCHAR szReinstallMode[] = {'R','E','I','N','S','T','A','L','L','M','O','D','E',0};
1910 static const WCHAR szOne[] = {'1',0};
1911 WCHAR reinstallmode[11];
1912 LPWSTR ptr;
1913 DWORD sz;
1914
1915 FIXME("%s %s %i\n", debugstr_w(szProduct), debugstr_w(szFeature),
1916 dwReinstallMode);
1917
1918 ptr = reinstallmode;
1919
1920 if (dwReinstallMode & REINSTALLMODE_FILEMISSING)
1921 *ptr++ = 'p';
1922 if (dwReinstallMode & REINSTALLMODE_FILEOLDERVERSION)
1923 *ptr++ = 'o';
1924 if (dwReinstallMode & REINSTALLMODE_FILEEQUALVERSION)
1925 *ptr++ = 'w';
1926 if (dwReinstallMode & REINSTALLMODE_FILEEXACT)
1927 *ptr++ = 'd';
1928 if (dwReinstallMode & REINSTALLMODE_FILEVERIFY)
1929 *ptr++ = 'c';
1930 if (dwReinstallMode & REINSTALLMODE_FILEREPLACE)
1931 *ptr++ = 'a';
1932 if (dwReinstallMode & REINSTALLMODE_USERDATA)
1933 *ptr++ = 'u';
1934 if (dwReinstallMode & REINSTALLMODE_MACHINEDATA)
1935 *ptr++ = 'm';
1936 if (dwReinstallMode & REINSTALLMODE_SHORTCUT)
1937 *ptr++ = 's';
1938 if (dwReinstallMode & REINSTALLMODE_PACKAGE)
1939 *ptr++ = 'v';
1940 *ptr = 0;
1941
1942 sz = sizeof(sourcepath);
1943 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
1944 MSICODE_PRODUCT, INSTALLPROPERTY_LASTUSEDSOURCEW, sourcepath, &sz);
1945
1946 sz = sizeof(filename);
1947 MsiSourceListGetInfoW(szProduct, NULL, MSIINSTALLCONTEXT_USERMANAGED,
1948 MSICODE_PRODUCT, INSTALLPROPERTY_PACKAGENAMEW, filename, &sz);
1949
1950 lstrcatW( sourcepath, filename );
1951
1952 if (dwReinstallMode & REINSTALLMODE_PACKAGE)
1953 r = MSI_OpenPackageW( sourcepath, &package );
1954 else
1955 r = MSI_OpenProductW( szProduct, &package );
1956
1957 if (r != ERROR_SUCCESS)
1958 return r;
1959
1960 MSI_SetPropertyW( package, szReinstallMode, reinstallmode );
1961 MSI_SetPropertyW( package, szInstalled, szOne );
1962 MSI_SetPropertyW( package, szLogVerbose, szOne );
1963 MSI_SetPropertyW( package, szReinstall, szFeature );
1964
1965 r = MSI_InstallPackage( package, sourcepath, NULL );
1966
1967 msiobj_release( &package->hdr );
1968
1969 return r;
1970 }
1971
1972 UINT WINAPI MsiReinstallFeatureA( LPCSTR szProduct, LPCSTR szFeature,
1973 DWORD dwReinstallMode )
1974 {
1975 LPWSTR wszProduct;
1976 LPWSTR wszFeature;
1977 UINT rc;
1978
1979 TRACE("%s %s %i\n", debugstr_a(szProduct), debugstr_a(szFeature),
1980 dwReinstallMode);
1981
1982 wszProduct = strdupAtoW(szProduct);
1983 wszFeature = strdupAtoW(szFeature);
1984
1985 rc = MsiReinstallFeatureW(wszProduct, wszFeature, dwReinstallMode);
1986
1987 msi_free(wszProduct);
1988 msi_free(wszFeature);
1989 return rc;
1990 }
1991
1992 typedef struct
1993 {
1994 unsigned int i[2];
1995 unsigned int buf[4];
1996 unsigned char in[64];
1997 unsigned char digest[16];
1998 } MD5_CTX;
1999
2000 extern VOID WINAPI MD5Init( MD5_CTX *);
2001 extern VOID WINAPI MD5Update( MD5_CTX *, const unsigned char *, unsigned int );
2002 extern VOID WINAPI MD5Final( MD5_CTX *);
2003
2004 /***********************************************************************
2005 * MsiGetFileHashW [MSI.@]
2006 */
2007 UINT WINAPI MsiGetFileHashW( LPCWSTR szFilePath, DWORD dwOptions,
2008 PMSIFILEHASHINFO pHash )
2009 {
2010 HANDLE handle, mapping;
2011 void *p;
2012 DWORD length;
2013 UINT r = ERROR_FUNCTION_FAILED;
2014
2015 TRACE("%s %08x %p\n", debugstr_w(szFilePath), dwOptions, pHash );
2016
2017 if (dwOptions)
2018 return ERROR_INVALID_PARAMETER;
2019 if (!pHash)
2020 return ERROR_INVALID_PARAMETER;
2021 if (pHash->dwFileHashInfoSize < sizeof *pHash)
2022 return ERROR_INVALID_PARAMETER;
2023
2024 handle = CreateFileW( szFilePath, GENERIC_READ,
2025 FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, 0, NULL );
2026 if (handle == INVALID_HANDLE_VALUE)
2027 return ERROR_FILE_NOT_FOUND;
2028
2029 length = GetFileSize( handle, NULL );
2030
2031 mapping = CreateFileMappingW( handle, NULL, PAGE_READONLY, 0, 0, NULL );
2032 if (mapping)
2033 {
2034 p = MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, length );
2035 if (p)
2036 {
2037 MD5_CTX ctx;
2038
2039 MD5Init( &ctx );
2040 MD5Update( &ctx, p, length );
2041 MD5Final( &ctx );
2042 UnmapViewOfFile( p );
2043
2044 memcpy( pHash->dwData, &ctx.digest, sizeof pHash->dwData );
2045 r = ERROR_SUCCESS;
2046 }
2047 CloseHandle( mapping );
2048 }
2049 CloseHandle( handle );
2050
2051 return r;
2052 }
2053
2054 /***********************************************************************
2055 * MsiGetFileHashA [MSI.@]
2056 */
2057 UINT WINAPI MsiGetFileHashA( LPCSTR szFilePath, DWORD dwOptions,
2058 PMSIFILEHASHINFO pHash )
2059 {
2060 LPWSTR file;
2061 UINT r;
2062
2063 TRACE("%s %08x %p\n", debugstr_a(szFilePath), dwOptions, pHash );
2064
2065 file = strdupAtoW( szFilePath );
2066 if (szFilePath && !file)
2067 return ERROR_OUTOFMEMORY;
2068
2069 r = MsiGetFileHashW( file, dwOptions, pHash );
2070 msi_free( file );
2071 return r;
2072 }
2073
2074 /***********************************************************************
2075 * MsiAdvertiseScriptW [MSI.@]
2076 */
2077 UINT WINAPI MsiAdvertiseScriptW( LPCWSTR szScriptFile, DWORD dwFlags,
2078 PHKEY phRegData, BOOL fRemoveItems )
2079 {
2080 FIXME("%s %08x %p %d\n",
2081 debugstr_w( szScriptFile ), dwFlags, phRegData, fRemoveItems );
2082 return ERROR_CALL_NOT_IMPLEMENTED;
2083 }
2084
2085 /***********************************************************************
2086 * MsiAdvertiseScriptA [MSI.@]
2087 */
2088 UINT WINAPI MsiAdvertiseScriptA( LPCSTR szScriptFile, DWORD dwFlags,
2089 PHKEY phRegData, BOOL fRemoveItems )
2090 {
2091 FIXME("%s %08x %p %d\n",
2092 debugstr_a( szScriptFile ), dwFlags, phRegData, fRemoveItems );
2093 return ERROR_CALL_NOT_IMPLEMENTED;
2094 }
GSOC 2012 project to enhance the control panel