msi: suminfo: Return ERROR_UNKNOWN_PROPERTY as native.
[wine] / dlls / msi / msi.c
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(*pcchVersionBuf*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, LPWSTR 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 }