If MsiGetProperty(A/W) is called with a NULL for the value buffer but
[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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "wine/unicode.h"
39 #include "action.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(msi);
42
43 /*
44  * The MSVC headers define the MSIDBOPEN_* macros cast to LPCTSTR,
45  *  which is a problem because LPCTSTR isn't defined when compiling wine.
46  * To work around this problem, we need to define LPCTSTR as LPCWSTR here,
47  *  and make sure to only use it in W functions.
48  */
49 #define LPCTSTR LPCWSTR
50
51 /* the UI level */
52 INSTALLUILEVEL gUILevel = INSTALLUILEVEL_BASIC;
53 HWND           gUIhwnd = 0;
54 INSTALLUI_HANDLERA gUIHandlerA = NULL;
55 INSTALLUI_HANDLERW gUIHandlerW = NULL;
56 DWORD gUIFilter = 0;
57 LPVOID gUIContext = NULL;
58 WCHAR gszLogFile[MAX_PATH];
59 HINSTANCE msi_hInstance;
60
61 static const WCHAR installerW[] = {'\\','I','n','s','t','a','l','l','e','r',0};
62
63 UINT WINAPI MsiOpenProductA(LPCSTR szProduct, MSIHANDLE *phProduct)
64 {
65     UINT r;
66     LPWSTR szwProd = NULL;
67
68     TRACE("%s %p\n",debugstr_a(szProduct), phProduct);
69
70     if( szProduct )
71     {
72         szwProd = strdupAtoW( szProduct );
73         if( !szwProd )
74             return ERROR_OUTOFMEMORY;
75     }
76
77     r = MsiOpenProductW( szwProd, phProduct );
78
79     HeapFree( GetProcessHeap(), 0, szwProd );
80
81     return r;
82 }
83
84 UINT WINAPI MsiOpenProductW(LPCWSTR szProduct, MSIHANDLE *phProduct)
85 {
86     static const WCHAR szLocalPackage[] = {
87         'L','o','c','a','l','P','a','c','k','a','g','e', 0
88     };
89     LPWSTR path = NULL;
90     UINT r;
91     HKEY hKeyProduct = NULL;
92     DWORD count, type;
93
94     TRACE("%s %p\n",debugstr_w(szProduct), phProduct);
95
96     r = MSIREG_OpenUninstallKey(szProduct,&hKeyProduct,FALSE);
97     if( r != ERROR_SUCCESS )
98     {
99         r = ERROR_UNKNOWN_PRODUCT;
100         goto end;
101     }
102
103     /* find the size of the path */
104     type = count = 0;
105     r = RegQueryValueExW( hKeyProduct, szLocalPackage,
106                           NULL, &type, NULL, &count );
107     if( r != ERROR_SUCCESS )
108     {
109         r = ERROR_UNKNOWN_PRODUCT;
110         goto end;
111     }
112
113     /* now alloc and fetch the path of the database to open */
114     path = HeapAlloc( GetProcessHeap(), 0, count );
115     if( !path )
116         goto end;
117
118     r = RegQueryValueExW( hKeyProduct, szLocalPackage,
119                           NULL, &type, (LPBYTE) path, &count );
120     if( r != ERROR_SUCCESS )
121     {
122         r = ERROR_UNKNOWN_PRODUCT;
123         goto end;
124     }
125
126     r = MsiOpenPackageW( path, phProduct );
127
128 end:
129     HeapFree( GetProcessHeap(), 0, path );
130     if( hKeyProduct )
131         RegCloseKey( hKeyProduct );
132
133     return r;
134 }
135
136 UINT WINAPI MsiAdvertiseProductA(LPCSTR szPackagePath, LPCSTR szScriptfilePath,
137                 LPCSTR szTransforms, LANGID lgidLanguage)
138 {
139     FIXME("%s %s %s %08x\n",debugstr_a(szPackagePath),
140           debugstr_a(szScriptfilePath), debugstr_a(szTransforms), lgidLanguage);
141     return ERROR_CALL_NOT_IMPLEMENTED;
142 }
143
144 UINT WINAPI MsiAdvertiseProductW(LPCWSTR szPackagePath, LPCWSTR szScriptfilePath,
145                 LPCWSTR szTransforms, LANGID lgidLanguage)
146 {
147     FIXME("%s %s %s %08x\n",debugstr_w(szPackagePath),
148           debugstr_w(szScriptfilePath), debugstr_w(szTransforms), lgidLanguage);
149     return ERROR_CALL_NOT_IMPLEMENTED;
150 }
151
152 UINT WINAPI MsiAdvertiseProductExA(LPCSTR szPackagePath, LPCSTR szScriptfilePath,
153       LPCSTR szTransforms, LANGID lgidLanguage, DWORD dwPlatform, DWORD dwOptions)
154 {
155     FIXME("%s %s %s %08x %08lx %08lx\n", debugstr_a(szPackagePath),
156           debugstr_a(szScriptfilePath), debugstr_a(szTransforms),
157           lgidLanguage, dwPlatform, dwOptions);
158     return ERROR_CALL_NOT_IMPLEMENTED;
159 }
160
161 UINT WINAPI MsiAdvertiseProductExW( LPCWSTR szPackagePath, LPCWSTR szScriptfilePath,
162       LPCWSTR szTransforms, LANGID lgidLanguage, DWORD dwPlatform, DWORD dwOptions)
163 {
164     FIXME("%s %s %s %08x %08lx %08lx\n", debugstr_w(szPackagePath),
165           debugstr_w(szScriptfilePath), debugstr_w(szTransforms),
166           lgidLanguage, dwPlatform, dwOptions);
167     return ERROR_CALL_NOT_IMPLEMENTED;
168 }
169
170 UINT WINAPI MsiInstallProductA(LPCSTR szPackagePath, LPCSTR szCommandLine)
171 {
172     LPWSTR szwPath = NULL, szwCommand = NULL;
173     UINT r = ERROR_OUTOFMEMORY;
174
175     TRACE("%s %s\n",debugstr_a(szPackagePath), debugstr_a(szCommandLine));
176
177     if( szPackagePath )
178     {
179         szwPath = strdupAtoW( szPackagePath );
180         if( !szwPath )
181             goto end;
182     }
183
184     if( szCommandLine )
185     {
186         szwCommand = strdupAtoW( szCommandLine );
187         if( !szwCommand )
188             goto end;
189     }
190
191     r = MsiInstallProductW( szwPath, szwCommand );
192
193 end:
194     HeapFree( GetProcessHeap(), 0, szwPath );
195     HeapFree( GetProcessHeap(), 0, szwCommand );
196
197     return r;
198 }
199
200 UINT WINAPI MsiInstallProductW(LPCWSTR szPackagePath, LPCWSTR szCommandLine)
201 {
202     MSIPACKAGE *package = NULL;
203     UINT r;
204     MSIHANDLE handle;
205     WCHAR path[MAX_PATH];
206     WCHAR filename[MAX_PATH];
207     static const WCHAR szMSI[] = {'M','S','I',0};
208
209     FIXME("%s %s\n",debugstr_w(szPackagePath), debugstr_w(szCommandLine));
210
211     r = MsiVerifyPackageW(szPackagePath);
212     if (r != ERROR_SUCCESS)
213         return r;
214
215     /* copy the msi file to a temp file to pervent locking a CD
216      * with a multi disc install 
217      */
218     GetTempPathW(MAX_PATH, path);
219     GetTempFileNameW(path, szMSI, 0, filename);
220
221     CopyFileW(szPackagePath, filename, FALSE);
222
223     TRACE("Opening relocated package %s\n",debugstr_w(filename));
224     r = MSI_OpenPackageW(filename, &package);
225     if (r != ERROR_SUCCESS)
226     {
227         DeleteFileW(filename);
228         return r;
229     }
230
231     handle = alloc_msihandle( &package->hdr );
232
233     r = ACTION_DoTopLevelINSTALL(package, szPackagePath, szCommandLine, 
234                                  filename);
235
236     MsiCloseHandle(handle);
237     msiobj_release( &package->hdr );
238
239     DeleteFileW(filename);
240     return r;
241 }
242
243 UINT WINAPI MsiReinstallProductA(LPCSTR szProduct, DWORD dwReinstallMode)
244 {
245     FIXME("%s %08lx\n", debugstr_a(szProduct), dwReinstallMode);
246     return ERROR_CALL_NOT_IMPLEMENTED;
247 }
248
249 UINT WINAPI MsiReinstallProductW(LPCWSTR szProduct, DWORD dwReinstallMode)
250 {
251     FIXME("%s %08lx\n", debugstr_w(szProduct), dwReinstallMode);
252     return ERROR_CALL_NOT_IMPLEMENTED;
253 }
254
255 UINT WINAPI MsiApplyPatchA(LPCSTR szPatchPackage, LPCSTR szInstallPackage,
256         INSTALLTYPE eInstallType, LPCSTR szCommandLine)
257 {
258     FIXME("%s %s %d %s\n", debugstr_a(szPatchPackage), debugstr_a(szInstallPackage),
259           eInstallType, debugstr_a(szCommandLine));
260     return ERROR_CALL_NOT_IMPLEMENTED;
261 }
262
263 UINT WINAPI MsiApplyPatchW(LPCWSTR szPatchPackage, LPCWSTR szInstallPackage,
264          INSTALLTYPE eInstallType, LPCWSTR szCommandLine)
265 {
266     FIXME("%s %s %d %s\n", debugstr_w(szPatchPackage), debugstr_w(szInstallPackage),
267           eInstallType, debugstr_w(szCommandLine));
268     return ERROR_CALL_NOT_IMPLEMENTED;
269 }
270
271 UINT WINAPI MsiConfigureProductExW(LPCWSTR szProduct, int iInstallLevel,
272                         INSTALLSTATE eInstallState, LPCWSTR szCommandLine)
273 {
274     MSIHANDLE handle = -1;
275     MSIPACKAGE* package;
276     UINT rc;
277     HKEY hkey=0,hkey1=0;
278     DWORD sz;
279     static const WCHAR szSouceList[] = {
280         'S','o','u','r','c','e','L','i','s','t',0};
281     static const WCHAR szLUS[] = {
282         'L','a','s','t','U','s','e','d','S','o','u','r','c','e',0};
283     WCHAR sourcepath[0x200];
284     static const WCHAR szInstalled[] = {
285         ' ','I','n','s','t','a','l','l','e','d','=','1',0};
286     LPWSTR commandline;
287
288     FIXME("%s %d %d %s\n",debugstr_w(szProduct), iInstallLevel, eInstallState,
289           debugstr_w(szCommandLine));
290
291     if (eInstallState != INSTALLSTATE_LOCAL &&
292         eInstallState != INSTALLSTATE_DEFAULT)
293     {
294         FIXME("Not implemented for anything other than local installs\n");
295         return ERROR_CALL_NOT_IMPLEMENTED;
296     }
297
298     rc = MSIREG_OpenUserProductsKey(szProduct,&hkey,FALSE);
299     if (rc != ERROR_SUCCESS)
300         goto end;
301
302     rc = RegOpenKeyW(hkey,szSouceList,&hkey1);
303     if (rc != ERROR_SUCCESS)
304         goto end;
305
306     sz = sizeof(sourcepath);
307     rc = RegQueryValueExW(hkey1, szLUS, NULL, NULL,(LPBYTE)sourcepath, &sz);
308     if (rc != ERROR_SUCCESS)
309         goto end;
310
311     RegCloseKey(hkey1);
312     /*
313      * ok 1, we need to find the msi file for this product.
314      *    2, find the source dir for the files
315      *    3, do the configure/install.
316      *    4, cleanupany runonce entry.
317      */
318
319     rc = MsiOpenProductW(szProduct,&handle);
320     if (rc != ERROR_SUCCESS)
321         goto end;
322
323     package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
324     if (!package)
325     {
326         rc = ERROR_INVALID_HANDLE;
327         goto end;
328     }
329
330     sz = lstrlenW(szInstalled);
331
332     if (szCommandLine)
333         sz += lstrlenW(szCommandLine);
334
335     commandline = HeapAlloc(GetProcessHeap(),0,sz * sizeof(WCHAR));
336
337     if (szCommandLine)
338         lstrcpyW(commandline,szCommandLine);
339     else
340         commandline[0] = 0;
341
342     if (MsiQueryProductStateW(szProduct) != INSTALLSTATE_UNKNOWN)
343         lstrcatW(commandline,szInstalled);
344
345     rc = ACTION_DoTopLevelINSTALL(package, sourcepath, commandline, sourcepath);
346
347     msiobj_release( &package->hdr );
348
349     HeapFree(GetProcessHeap(),0,commandline);
350 end:
351     RegCloseKey(hkey);
352     if (handle != -1)
353         MsiCloseHandle(handle);
354
355     return rc;
356 }
357
358 UINT WINAPI MsiConfigureProductExA(LPCSTR szProduct, int iInstallLevel,
359                         INSTALLSTATE eInstallState, LPCSTR szCommandLine)
360 {
361     LPWSTR szwProduct = NULL;
362     LPWSTR szwCommandLine = NULL;
363     UINT r = ERROR_OUTOFMEMORY;
364
365     if( szProduct )
366     {
367         szwProduct = strdupAtoW( szProduct );
368         if( !szwProduct )
369             goto end;
370     }
371
372     if( szCommandLine)
373     {
374         szwCommandLine = strdupAtoW( szCommandLine );
375         if( !szwCommandLine)
376             goto end;
377     }
378
379     r = MsiConfigureProductExW( szwProduct, iInstallLevel, eInstallState,
380                                 szwCommandLine );
381 end:
382     HeapFree( GetProcessHeap(), 0, szwProduct );
383     HeapFree( GetProcessHeap(), 0, szwCommandLine);
384
385     return r;
386 }
387
388 UINT WINAPI MsiConfigureProductA(LPCSTR szProduct, int iInstallLevel,
389                                  INSTALLSTATE eInstallState)
390 {
391     LPWSTR szwProduct = NULL;
392     UINT r;
393
394     TRACE("%s %d %d\n",debugstr_a(szProduct), iInstallLevel, eInstallState);
395
396     if( szProduct )
397     {
398         szwProduct = strdupAtoW( szProduct );
399         if( !szwProduct )
400             return ERROR_OUTOFMEMORY;
401     }
402
403     r = MsiConfigureProductW( szwProduct, iInstallLevel, eInstallState );
404     HeapFree( GetProcessHeap(), 0, szwProduct );
405
406     return r;
407 }
408
409 UINT WINAPI MsiConfigureProductW(LPCWSTR szProduct, int iInstallLevel,
410                                  INSTALLSTATE eInstallState)
411 {
412     FIXME("%s %d %d\n", debugstr_w(szProduct), iInstallLevel, eInstallState);
413
414     return MsiConfigureProductExW(szProduct, iInstallLevel, eInstallState, NULL);
415 }
416
417 UINT WINAPI MsiGetProductCodeA(LPCSTR szComponent, LPSTR szBuffer)
418 {
419     LPWSTR szwComponent = NULL;
420     UINT r;
421     WCHAR szwBuffer[GUID_SIZE];
422
423     TRACE("%s %s\n",debugstr_a(szComponent), debugstr_a(szBuffer));
424
425     if( szComponent )
426     {
427         szwComponent = strdupAtoW( szComponent );
428         if( !szwComponent )
429             return ERROR_OUTOFMEMORY;
430     }
431
432     r = MsiGetProductCodeW( szwComponent, szwBuffer );
433
434     if( ERROR_SUCCESS == r )
435         WideCharToMultiByte(CP_ACP, 0, szwBuffer, -1, szBuffer, GUID_SIZE, NULL, NULL);
436
437     HeapFree( GetProcessHeap(), 0, szwComponent );
438
439     return r;
440 }
441
442 UINT WINAPI MsiGetProductCodeW(LPCWSTR szComponent, LPWSTR szBuffer)
443 {
444     UINT rc;
445     HKEY hkey;
446     WCHAR szSquished[GUID_SIZE];
447     DWORD sz = GUID_SIZE;
448     static const WCHAR szPermKey[] =
449         { '0','0','0','0','0','0','0','0','0','0','0','0',
450           '0','0','0','0','0','0','0', '0','0','0','0','0',
451           '0','0','0','0','0','0','0','0',0};
452
453     TRACE("%s %p\n",debugstr_w(szComponent), szBuffer);
454
455     if (NULL == szComponent)
456         return ERROR_INVALID_PARAMETER;
457
458     rc = MSIREG_OpenComponentsKey( szComponent, &hkey, FALSE);
459     if (rc != ERROR_SUCCESS)
460         return ERROR_UNKNOWN_COMPONENT;
461
462     rc = RegEnumValueW(hkey, 0, szSquished, &sz, NULL, NULL, NULL, NULL);
463     if (rc == ERROR_SUCCESS && strcmpW(szSquished,szPermKey)==0)
464     {
465         sz = GUID_SIZE;
466         rc = RegEnumValueW(hkey, 1, szSquished, &sz, NULL, NULL, NULL, NULL);
467     }
468
469     RegCloseKey(hkey);
470
471     if (rc != ERROR_SUCCESS)
472         return ERROR_INSTALL_FAILURE;
473
474     unsquash_guid(szSquished, szBuffer);
475     return ERROR_SUCCESS;
476 }
477
478 UINT WINAPI MsiGetProductInfoA(LPCSTR szProduct, LPCSTR szAttribute,
479                  LPSTR szBuffer, DWORD *pcchValueBuf)
480 {
481     LPWSTR szwProduct = NULL, szwAttribute = NULL, szwBuffer = NULL;
482     UINT r = ERROR_OUTOFMEMORY;
483     DWORD pcchwValueBuf = 0;
484
485     TRACE("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szAttribute),
486           szBuffer, pcchValueBuf);
487
488     if( szProduct )
489     {
490         szwProduct = strdupAtoW( szProduct );
491         if( !szwProduct )
492             goto end;
493     }
494     
495     if( szAttribute )
496     {
497         szwAttribute = strdupAtoW( szAttribute );
498         if( !szwAttribute )
499             goto end;
500     }
501
502     if( szBuffer )
503     {
504         szwBuffer = HeapAlloc( GetProcessHeap(), 0, (*pcchValueBuf) * sizeof(WCHAR) );
505         pcchwValueBuf = *pcchValueBuf;
506         if( !szwBuffer )     
507             goto end;
508     }
509
510     r = MsiGetProductInfoW( szwProduct, szwAttribute, szwBuffer, 
511                             &pcchwValueBuf );
512
513     if( ERROR_SUCCESS == r )
514         *pcchValueBuf = WideCharToMultiByte(CP_ACP, 0, szwBuffer, pcchwValueBuf,
515                         szBuffer, *pcchValueBuf, NULL, NULL);
516
517 end:
518     HeapFree( GetProcessHeap(), 0, szwProduct );
519     HeapFree( GetProcessHeap(), 0, szwAttribute );
520     HeapFree( GetProcessHeap(), 0, szwBuffer );
521
522     return r;
523 }
524
525 UINT WINAPI MsiGetProductInfoW(LPCWSTR szProduct, LPCWSTR szAttribute,
526                 LPWSTR szBuffer, DWORD *pcchValueBuf)
527 {
528     MSIHANDLE hProduct;
529     UINT r;
530     static const WCHAR szPackageCode[] =
531         {'P','a','c','k','a','g','e','C','o','d','e',0};
532     static const WCHAR szVersionString[] =
533         {'V','e','r','s','i','o','n','S','t','r','i','n','g',0};
534     static const WCHAR szProductVersion[] =
535         {'P','r','o','d','u','c','t','V','e','r','s','i','o','n',0};
536     static const WCHAR szAssignmentType[] =
537         {'A','s','s','i','g','n','m','e','n','t','T','y','p','e',0};
538     static const WCHAR szLanguage[] =
539         {'L','a','n','g','u','a','g','e',0};
540     static const WCHAR szProductLanguage[] =
541         {'P','r','o','d','u','c','t','L','a','n','g','u','a','g','e',0};
542
543     FIXME("%s %s %p %p\n",debugstr_w(szProduct), debugstr_w(szAttribute),
544           szBuffer, pcchValueBuf);
545
546     if (NULL != szBuffer && NULL == pcchValueBuf)
547         return ERROR_INVALID_PARAMETER;
548     if (NULL == szProduct || NULL == szAttribute)
549         return ERROR_INVALID_PARAMETER;
550     
551     /* check for special properties */
552     if (strcmpW(szAttribute, szPackageCode)==0)
553     {
554         HKEY hkey;
555         WCHAR squished[GUID_SIZE];
556         WCHAR package[200];
557         DWORD sz = sizeof(squished);
558
559         r = MSIREG_OpenUserProductsKey(szProduct, &hkey, FALSE);
560         if (r != ERROR_SUCCESS)
561             return ERROR_UNKNOWN_PRODUCT;
562
563         r = RegQueryValueExW(hkey, szPackageCode, NULL, NULL, 
564                         (LPBYTE)squished, &sz);
565         if (r != ERROR_SUCCESS)
566         {
567             RegCloseKey(hkey);
568             return ERROR_UNKNOWN_PRODUCT;
569         }
570
571         unsquash_guid(squished, package);
572         *pcchValueBuf = strlenW(package);
573         if (strlenW(package) > *pcchValueBuf)
574         {
575             RegCloseKey(hkey);
576             return ERROR_MORE_DATA;
577         }
578         else
579             strcpyW(szBuffer, package);
580
581         RegCloseKey(hkey);
582         r = ERROR_SUCCESS;
583     }
584     else if (strcmpW(szAttribute, szVersionString)==0)
585     {
586         r = MsiOpenProductW(szProduct, &hProduct);
587         if (ERROR_SUCCESS != r)
588             return r;
589
590         r = MsiGetPropertyW(hProduct, szProductVersion, szBuffer, pcchValueBuf);
591         MsiCloseHandle(hProduct);
592     }
593     else if (strcmpW(szAttribute, szAssignmentType)==0)
594     {
595         FIXME("0 (zero) if advertised or per user , 1(one) if per machine.\n");
596         if (szBuffer)
597         {
598             szBuffer[0] = '1';
599             szBuffer[1] = 0;
600         }
601         if (pcchValueBuf)
602             *pcchValueBuf = 1;
603         r = ERROR_SUCCESS;
604     }
605     else if (strcmpW(szAttribute, szLanguage)==0)
606     {
607         r = MsiOpenProductW(szProduct, &hProduct);
608         if (ERROR_SUCCESS != r)
609             return r;
610
611         r = MsiGetPropertyW(hProduct, szProductLanguage, szBuffer, pcchValueBuf);
612         MsiCloseHandle(hProduct);
613     }
614     else
615     {
616         r = MsiOpenProductW(szProduct, &hProduct);
617         if (ERROR_SUCCESS != r)
618             return r;
619
620         r = MsiGetPropertyW(hProduct, szAttribute, szBuffer, pcchValueBuf);
621         MsiCloseHandle(hProduct);
622     }
623
624     return r;
625 }
626
627 UINT WINAPI MsiEnableLogA(DWORD dwLogMode, LPCSTR szLogFile, DWORD attributes)
628 {
629     LPWSTR szwLogFile = NULL;
630     UINT r;
631
632     TRACE("%08lx %s %08lx\n", dwLogMode, debugstr_a(szLogFile), attributes);
633
634     if( szLogFile )
635     {
636         szwLogFile = strdupAtoW( szLogFile );
637         if( !szwLogFile )
638             return ERROR_OUTOFMEMORY;
639     }
640     r = MsiEnableLogW( dwLogMode, szwLogFile, attributes );
641     HeapFree( GetProcessHeap(), 0, szwLogFile );
642     return r;
643 }
644
645 UINT WINAPI MsiEnableLogW(DWORD dwLogMode, LPCWSTR szLogFile, DWORD attributes)
646 {
647     HANDLE file = INVALID_HANDLE_VALUE;
648
649     TRACE("%08lx %s %08lx\n", dwLogMode, debugstr_w(szLogFile), attributes);
650
651     lstrcpyW(gszLogFile,szLogFile);
652     if (!(attributes & INSTALLLOGATTRIBUTES_APPEND))
653         DeleteFileW(szLogFile);
654     file = CreateFileW(szLogFile, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS,
655                            FILE_ATTRIBUTE_NORMAL, NULL);
656     if (file != INVALID_HANDLE_VALUE)
657         CloseHandle(file);
658     else
659         ERR("Unable to enable log %s\n",debugstr_w(szLogFile));
660
661     return ERROR_SUCCESS;
662 }
663
664 INSTALLSTATE WINAPI MsiQueryProductStateA(LPCSTR szProduct)
665 {
666     LPWSTR szwProduct = NULL;
667     INSTALLSTATE r;
668
669     if( szProduct )
670     {
671          szwProduct = strdupAtoW( szProduct );
672          if( !szwProduct )
673              return ERROR_OUTOFMEMORY;
674     }
675     r = MsiQueryProductStateW( szwProduct );
676     HeapFree( GetProcessHeap(), 0, szwProduct );
677     return r;
678 }
679
680 INSTALLSTATE WINAPI MsiQueryProductStateW(LPCWSTR szProduct)
681 {
682     UINT rc;
683     INSTALLSTATE rrc = INSTALLSTATE_UNKNOWN;
684     HKEY hkey = 0;
685     static const WCHAR szWindowsInstaller[] = {
686          'W','i','n','d','o','w','s','I','n','s','t','a','l','l','e','r',0 };
687     DWORD sz;
688
689     TRACE("%s\n", debugstr_w(szProduct));
690
691     rc = MSIREG_OpenUserProductsKey(szProduct,&hkey,FALSE);
692     if (rc != ERROR_SUCCESS)
693         goto end;
694
695     RegCloseKey(hkey);
696
697     rc = MSIREG_OpenUninstallKey(szProduct,&hkey,FALSE);
698     if (rc != ERROR_SUCCESS)
699         goto end;
700
701     sz = sizeof(rrc);
702     rc = RegQueryValueExW(hkey,szWindowsInstaller,NULL,NULL,(LPVOID)&rrc, &sz);
703     if (rc != ERROR_SUCCESS)
704         goto end;
705
706     switch (rrc)
707     {
708     case 1:
709         /* default */
710         rrc = INSTALLSTATE_DEFAULT;
711         break;
712     default:
713         FIXME("Unknown install state read from registry (%i)\n",rrc);
714         rrc = INSTALLSTATE_UNKNOWN;
715         break;
716     }
717 end:
718     RegCloseKey(hkey);
719     return rrc;
720 }
721
722 INSTALLUILEVEL WINAPI MsiSetInternalUI(INSTALLUILEVEL dwUILevel, HWND *phWnd)
723 {
724     INSTALLUILEVEL old = gUILevel;
725     HWND oldwnd = gUIhwnd;
726
727     TRACE("%08x %p\n", dwUILevel, phWnd);
728
729     gUILevel = dwUILevel;
730     if (phWnd)
731     {
732         gUIhwnd = *phWnd;
733         *phWnd = oldwnd;
734     }
735     return old;
736 }
737
738 INSTALLUI_HANDLERA WINAPI MsiSetExternalUIA(INSTALLUI_HANDLERA puiHandler,
739                                   DWORD dwMessageFilter, LPVOID pvContext)
740 {
741     INSTALLUI_HANDLERA prev = gUIHandlerA;
742
743     TRACE("%p %lx %p\n",puiHandler, dwMessageFilter,pvContext);
744     gUIHandlerA = puiHandler;
745     gUIFilter = dwMessageFilter;
746     gUIContext = pvContext;
747
748     return prev;
749 }
750
751 INSTALLUI_HANDLERW WINAPI MsiSetExternalUIW(INSTALLUI_HANDLERW puiHandler,
752                                   DWORD dwMessageFilter, LPVOID pvContext)
753 {
754     INSTALLUI_HANDLERW prev = gUIHandlerW;
755
756     TRACE("%p %lx %p\n",puiHandler,dwMessageFilter,pvContext);
757     gUIHandlerW = puiHandler;
758     gUIFilter = dwMessageFilter;
759     gUIContext = pvContext;
760
761     return prev;
762 }
763
764 /******************************************************************
765  *  MsiLoadStringW            [MSI.@]
766  *
767  * Loads a string from MSI's string resources.
768  *
769  * PARAMS
770  *
771  *   handle        [I]  only -1 is handled currently
772  *   id            [I]  id of the string to be loaded
773  *   lpBuffer      [O]  buffer for the string to be written to
774  *   nBufferMax    [I]  maximum size of the buffer in characters
775  *   lang          [I]  the preferred language for the string
776  *
777  * RETURNS
778  *
779  *   If successful, this function returns the language id of the string loaded
780  *   If the function fails, the function returns zero.
781  *
782  * NOTES
783  *
784  *   The type of the first parameter is unknown.  LoadString's prototype
785  *  suggests that it might be a module handle.  I have made it an MSI handle
786  *  for starters, as -1 is an invalid MSI handle, but not an invalid module
787  *  handle.  Maybe strings can be stored in an MSI database somehow.
788  */
789 LANGID WINAPI MsiLoadStringW( MSIHANDLE handle, UINT id, LPWSTR lpBuffer,
790                 int nBufferMax, LANGID lang )
791 {
792     HRSRC hres;
793     HGLOBAL hResData;
794     LPWSTR p;
795     DWORD i, len;
796
797     TRACE("%ld %u %p %d %d\n", handle, id, lpBuffer, nBufferMax, lang);
798
799     if( handle != -1 )
800         FIXME("don't know how to deal with handle = %08lx\n", handle);
801
802     if( !lang )
803         lang = GetUserDefaultLangID();
804
805     hres = FindResourceExW( msi_hInstance, (LPCWSTR) RT_STRING,
806                             (LPWSTR)1, lang );
807     if( !hres )
808         return 0;
809     hResData = LoadResource( msi_hInstance, hres );
810     if( !hResData )
811         return 0;
812     p = LockResource( hResData );
813     if( !p )
814         return 0;
815
816     for (i = 0; i < (id&0xf); i++)
817         p += *p + 1;
818     len = *p;
819
820     if( nBufferMax <= len )
821         return 0;
822
823     memcpy( lpBuffer, p+1, len * sizeof(WCHAR));
824     lpBuffer[ len ] = 0;
825
826     TRACE("found -> %s\n", debugstr_w(lpBuffer));
827
828     return lang;
829 }
830
831 LANGID WINAPI MsiLoadStringA( MSIHANDLE handle, UINT id, LPSTR lpBuffer,
832                 int nBufferMax, LANGID lang )
833 {
834     LPWSTR bufW;
835     LANGID r;
836     DWORD len;
837
838     bufW = HeapAlloc(GetProcessHeap(), 0, nBufferMax*sizeof(WCHAR));
839     r = MsiLoadStringW(handle, id, bufW, nBufferMax, lang);
840     if( r )
841     {
842         len = WideCharToMultiByte(CP_ACP, 0, bufW, -1, NULL, 0, NULL, NULL );
843         if( len <= nBufferMax )
844             WideCharToMultiByte( CP_ACP, 0, bufW, -1,
845                                  lpBuffer, nBufferMax, NULL, NULL );
846         else
847             r = 0;
848     }
849     HeapFree(GetProcessHeap(), 0, bufW);
850     return r;
851 }
852
853 INSTALLSTATE WINAPI MsiLocateComponentA(LPCSTR szComponent, LPSTR lpPathBuf,
854                 DWORD *pcchBuf)
855 {
856     FIXME("%s %p %p\n", debugstr_a(szComponent), lpPathBuf, pcchBuf);
857     return INSTALLSTATE_UNKNOWN;
858 }
859
860 INSTALLSTATE WINAPI MsiLocateComponentW(LPCWSTR szComponent, LPWSTR lpPathBuf,
861                 DWORD *pcchBuf)
862 {
863     FIXME("%s %p %p\n", debugstr_w(szComponent), lpPathBuf, pcchBuf);
864     return INSTALLSTATE_UNKNOWN;
865 }
866
867 UINT WINAPI MsiMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,
868                 WORD wLanguageId, DWORD f)
869 {
870     FIXME("%p %s %s %u %08x %08lx\n",hWnd,debugstr_a(lpText),debugstr_a(lpCaption),
871           uType,wLanguageId,f);
872     return ERROR_CALL_NOT_IMPLEMENTED;
873 }
874
875 UINT WINAPI MsiMessageBoxW(HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,
876                 WORD wLanguageId, DWORD f)
877 {
878     FIXME("%p %s %s %u %08x %08lx\n",hWnd,debugstr_w(lpText),debugstr_w(lpCaption),
879           uType,wLanguageId,f);
880     return ERROR_CALL_NOT_IMPLEMENTED;
881 }
882
883 UINT WINAPI MsiProvideAssemblyA( LPCSTR szAssemblyName, LPCSTR szAppContext,
884                 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPSTR lpPathBuf,
885                 DWORD* pcchPathBuf )
886 {
887     FIXME("%s %s %08lx %08lx %p %p\n", debugstr_a(szAssemblyName),
888           debugstr_a(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
889           pcchPathBuf);
890     return ERROR_CALL_NOT_IMPLEMENTED;
891 }
892
893 UINT WINAPI MsiProvideAssemblyW( LPCWSTR szAssemblyName, LPCWSTR szAppContext,
894                 DWORD dwInstallMode, DWORD dwAssemblyInfo, LPWSTR lpPathBuf,
895                 DWORD* pcchPathBuf )
896 {
897     FIXME("%s %s %08lx %08lx %p %p\n", debugstr_w(szAssemblyName),
898           debugstr_w(szAppContext), dwInstallMode, dwAssemblyInfo, lpPathBuf,
899           pcchPathBuf);
900     return ERROR_CALL_NOT_IMPLEMENTED;
901 }
902
903 UINT WINAPI MsiProvideComponentFromDescriptorA( LPCSTR szDescriptor,
904                 LPSTR szPath, DWORD *pcchPath, DWORD *pcchArgs )
905 {
906     FIXME("%s %p %p %p\n", debugstr_a(szDescriptor), szPath, pcchPath, pcchArgs );
907     return ERROR_CALL_NOT_IMPLEMENTED;
908 }
909
910 UINT WINAPI MsiProvideComponentFromDescriptorW( LPCWSTR szDescriptor,
911                 LPWSTR szPath, DWORD *pcchPath, DWORD *pcchArgs )
912 {
913     FIXME("%s %p %p %p\n", debugstr_w(szDescriptor), szPath, pcchPath, pcchArgs );
914     return ERROR_CALL_NOT_IMPLEMENTED;
915 }
916
917 HRESULT WINAPI MsiGetFileSignatureInformationA( LPCSTR szSignedObjectPath,
918                 DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, BYTE* pbHashData,
919                 DWORD* pcbHashData)
920 {
921     FIXME("%s %08lx %p %p %p\n", debugstr_a(szSignedObjectPath), dwFlags,
922           ppcCertContext, pbHashData, pcbHashData);
923     return ERROR_CALL_NOT_IMPLEMENTED;
924 }
925
926 HRESULT WINAPI MsiGetFileSignatureInformationW( LPCWSTR szSignedObjectPath,
927                 DWORD dwFlags, PCCERT_CONTEXT* ppcCertContext, BYTE* pbHashData,
928                 DWORD* pcbHashData)
929 {
930     FIXME("%s %08lx %p %p %p\n", debugstr_w(szSignedObjectPath), dwFlags,
931           ppcCertContext, pbHashData, pcbHashData);
932     return ERROR_CALL_NOT_IMPLEMENTED;
933 }
934
935 UINT WINAPI MsiGetProductPropertyA( MSIHANDLE hProduct, LPCSTR szProperty,
936                                     LPSTR szValue, DWORD *pccbValue )
937 {
938     FIXME("%ld %s %p %p\n", hProduct, debugstr_a(szProperty), szValue, pccbValue);
939     return ERROR_CALL_NOT_IMPLEMENTED;
940 }
941
942 UINT WINAPI MsiGetProductPropertyW( MSIHANDLE hProduct, LPCWSTR szProperty,
943                                     LPWSTR szValue, DWORD *pccbValue )
944 {
945     FIXME("%ld %s %p %p\n", hProduct, debugstr_w(szProperty), szValue, pccbValue);
946     return ERROR_CALL_NOT_IMPLEMENTED;
947 }
948
949 UINT WINAPI MsiVerifyPackageA( LPCSTR szPackage )
950 {
951     UINT r;
952     LPWSTR szPack = NULL;
953
954     TRACE("%s\n", debugstr_a(szPackage) );
955
956     if( szPackage )
957     {
958         szPack = strdupAtoW( szPackage );
959         if( !szPack )
960             return ERROR_OUTOFMEMORY;
961     }
962
963     r = MsiVerifyPackageW( szPack );
964
965     HeapFree( GetProcessHeap(), 0, szPack );
966
967     return r;
968 }
969
970 UINT WINAPI MsiVerifyPackageW( LPCWSTR szPackage )
971 {
972     MSIHANDLE handle;
973     UINT r;
974
975     TRACE("%s\n", debugstr_w(szPackage) );
976
977     r = MsiOpenDatabaseW( szPackage, MSIDBOPEN_READONLY, &handle );
978     MsiCloseHandle( handle );
979
980     return r;
981 }
982
983 INSTALLSTATE WINAPI MsiGetComponentPathA(LPCSTR szProduct, LPCSTR szComponent,
984                                          LPSTR lpPathBuf, DWORD* pcchBuf)
985 {
986     LPWSTR szwProduct = NULL, szwComponent = NULL, lpwPathBuf= NULL;
987     INSTALLSTATE rc;
988     UINT incoming_len;
989
990     if( szProduct )
991     {
992         szwProduct = strdupAtoW( szProduct );
993         if( !szwProduct)
994             return ERROR_OUTOFMEMORY;
995     }
996
997     if( szComponent )
998     {
999         szwComponent = strdupAtoW( szComponent );
1000         if( !szwComponent )
1001         {
1002             HeapFree( GetProcessHeap(), 0, szwProduct);
1003             return ERROR_OUTOFMEMORY;
1004         }
1005     }
1006
1007     if( pcchBuf && *pcchBuf > 0 )
1008     {
1009         lpwPathBuf = HeapAlloc( GetProcessHeap(), 0, *pcchBuf * sizeof(WCHAR));
1010         incoming_len = *pcchBuf;
1011     }
1012     else
1013     {
1014         lpwPathBuf = NULL;
1015         incoming_len = 0;
1016     }
1017
1018     rc = MsiGetComponentPathW(szwProduct, szwComponent, lpwPathBuf, pcchBuf);
1019
1020     HeapFree( GetProcessHeap(), 0, szwProduct);
1021     HeapFree( GetProcessHeap(), 0, szwComponent);
1022     if (lpwPathBuf)
1023     {
1024         if (rc != INSTALLSTATE_UNKNOWN)
1025             WideCharToMultiByte(CP_ACP, 0, lpwPathBuf, incoming_len,
1026                             lpPathBuf, incoming_len, NULL, NULL);
1027         HeapFree( GetProcessHeap(), 0, lpwPathBuf);
1028     }
1029
1030     return rc;
1031 }
1032
1033 INSTALLSTATE WINAPI MsiGetComponentPathW(LPCWSTR szProduct, LPCWSTR szComponent,
1034                                          LPWSTR lpPathBuf, DWORD* pcchBuf)
1035 {
1036     WCHAR squished_pc[GUID_SIZE];
1037     UINT rc;
1038     INSTALLSTATE rrc = INSTALLSTATE_UNKNOWN;
1039     HKEY hkey = 0;
1040     LPWSTR path = NULL;
1041     DWORD sz, type;
1042
1043     TRACE("%s %s %p %p\n", debugstr_w(szProduct),
1044            debugstr_w(szComponent), lpPathBuf, pcchBuf);
1045
1046     if( lpPathBuf && !pcchBuf )
1047         return INSTALLSTATE_INVALIDARG;
1048
1049     squash_guid(szProduct,squished_pc);
1050
1051     rc = MSIREG_OpenProductsKey( szProduct, &hkey, FALSE);
1052     if( rc != ERROR_SUCCESS )
1053         goto end;
1054
1055     RegCloseKey(hkey);
1056
1057     rc = MSIREG_OpenComponentsKey( szComponent, &hkey, FALSE);
1058     if( rc != ERROR_SUCCESS )
1059         goto end;
1060
1061     sz = 0;
1062     type = 0;
1063     rc = RegQueryValueExW( hkey, squished_pc, NULL, &type, NULL, &sz );
1064     if( rc != ERROR_SUCCESS )
1065         goto end;
1066     if( type != REG_SZ )
1067         goto end;
1068
1069     sz += sizeof(WCHAR);
1070     path = HeapAlloc( GetProcessHeap(), 0, sz );
1071     if( !path )
1072         goto end;
1073
1074     rc = RegQueryValueExW( hkey, squished_pc, NULL, NULL, (LPVOID) path, &sz );
1075     if( rc != ERROR_SUCCESS )
1076         goto end;
1077
1078     TRACE("found path of (%s:%s)(%s)\n", debugstr_w(szComponent),
1079            debugstr_w(szProduct), debugstr_w(path));
1080
1081     if (path[0]=='0')
1082     {
1083         FIXME("Registry entry.. check entry\n");
1084         rrc = INSTALLSTATE_LOCAL;
1085     }
1086     else
1087     {
1088         /* PROBABLY a file */
1089         if ( GetFileAttributesW(path) != INVALID_FILE_ATTRIBUTES )
1090             rrc = INSTALLSTATE_LOCAL;
1091         else
1092             rrc = INSTALLSTATE_ABSENT;
1093     }
1094
1095     if( pcchBuf )
1096     {
1097         sz = sz / sizeof(WCHAR);
1098         if( *pcchBuf >= sz )
1099             lstrcpyW( lpPathBuf, path );
1100         *pcchBuf = sz;
1101     }
1102
1103 end:
1104     HeapFree(GetProcessHeap(), 0, path );
1105     RegCloseKey(hkey);
1106     return rrc;
1107 }
1108
1109 /******************************************************************
1110  * MsiQueryFeatureStateA      [MSI.@]
1111  */
1112 INSTALLSTATE WINAPI MsiQueryFeatureStateA(LPCSTR szProduct, LPCSTR szFeature)
1113 {
1114     INSTALLSTATE rc;
1115     LPWSTR szwProduct= NULL;
1116     LPWSTR szwFeature= NULL;
1117
1118     if( szProduct )
1119     {
1120         szwProduct = strdupAtoW( szProduct );
1121         if( !szwProduct)
1122             return ERROR_OUTOFMEMORY;
1123     }
1124
1125     if( szFeature )
1126     {
1127         szwFeature = strdupAtoW( szFeature );
1128         if( !szwFeature)
1129         {
1130             HeapFree( GetProcessHeap(), 0, szwProduct);
1131             return ERROR_OUTOFMEMORY;
1132         }
1133     }
1134
1135     rc = MsiQueryFeatureStateW(szwProduct, szwFeature);
1136
1137     HeapFree( GetProcessHeap(), 0, szwProduct);
1138     HeapFree( GetProcessHeap(), 0, szwFeature);
1139
1140     return rc;
1141 }
1142
1143 /******************************************************************
1144  * MsiQueryFeatureStateW      [MSI.@]
1145  *
1146  * This does not verify that the Feature is functional. So i am only going to
1147  * check the existence of the key in the registry. This should tell me if it is
1148  * installed.
1149  */
1150 INSTALLSTATE WINAPI MsiQueryFeatureStateW(LPCWSTR szProduct, LPCWSTR szFeature)
1151 {
1152     UINT rc;
1153     DWORD sz = 0;
1154     HKEY hkey;
1155
1156     TRACE("%s %s\n", debugstr_w(szProduct), debugstr_w(szFeature));
1157
1158     rc = MSIREG_OpenFeaturesKey(szProduct, &hkey, FALSE);
1159     if (rc != ERROR_SUCCESS)
1160         return INSTALLSTATE_UNKNOWN;
1161
1162     rc = RegQueryValueExW( hkey, szFeature, NULL, NULL, NULL, &sz);
1163     RegCloseKey(hkey);
1164
1165     if (rc == ERROR_SUCCESS)
1166         return INSTALLSTATE_LOCAL;
1167     else
1168         return INSTALLSTATE_ABSENT;
1169 }
1170
1171 /******************************************************************
1172  * MsiGetFileVersionA         [MSI.@]
1173  */
1174 UINT WINAPI MsiGetFileVersionA(LPCSTR szFilePath, LPSTR lpVersionBuf,
1175                 DWORD* pcchVersionBuf, LPSTR lpLangBuf, DWORD* pcchLangBuf)
1176 {
1177     LPWSTR szwFilePath = NULL, lpwVersionBuff = NULL, lpwLangBuff = NULL;
1178     UINT ret = ERROR_OUTOFMEMORY;
1179
1180     if( szFilePath )
1181     {
1182         szwFilePath = strdupAtoW( szFilePath );
1183         if( !szwFilePath )
1184             goto end;
1185     }
1186
1187     if( lpVersionBuf && pcchVersionBuf && *pcchVersionBuf )
1188     {
1189         lpwVersionBuff = HeapAlloc(GetProcessHeap(), 0, *pcchVersionBuf*sizeof(WCHAR));
1190         if( !lpwVersionBuff )
1191             goto end;
1192     }
1193
1194     if( lpLangBuf && pcchLangBuf && *pcchLangBuf )
1195     {
1196         lpwLangBuff = HeapAlloc(GetProcessHeap(), 0, *pcchVersionBuf*sizeof(WCHAR));
1197         if( !lpwLangBuff )
1198             goto end;
1199     }
1200
1201     ret = MsiGetFileVersionW(szwFilePath, lpwVersionBuff, pcchVersionBuf,
1202                              lpwLangBuff, pcchLangBuf);
1203
1204     if( lpwVersionBuff )
1205         WideCharToMultiByte(CP_ACP, 0, lpwVersionBuff, -1,
1206                             lpVersionBuf, *pcchVersionBuf, NULL, NULL);
1207     if( lpwLangBuff )
1208         WideCharToMultiByte(CP_ACP, 0, lpwLangBuff, -1,
1209                             lpLangBuf, *pcchLangBuf, NULL, NULL);
1210
1211 end:
1212     HeapFree(GetProcessHeap(), 0, szwFilePath);
1213     HeapFree(GetProcessHeap(), 0, lpwVersionBuff);
1214     HeapFree(GetProcessHeap(), 0, lpwLangBuff);
1215
1216     return ret;
1217 }
1218
1219 /******************************************************************
1220  * MsiGetFileVersionW         [MSI.@]
1221  */
1222 UINT WINAPI MsiGetFileVersionW(LPCWSTR szFilePath, LPWSTR lpVersionBuf,
1223                 DWORD* pcchVersionBuf, LPWSTR lpLangBuf, DWORD* pcchLangBuf)
1224 {
1225     static const WCHAR szVersionResource[] = {'\\',0};
1226     static const WCHAR szVersionFormat[] = {
1227         '%','d','.','%','d','.','%','d','.','%','d',0};
1228     static const WCHAR szLangFormat[] = {'%','d',0};
1229     UINT ret = 0;
1230     DWORD dwVerLen;
1231     LPVOID lpVer = NULL;
1232     VS_FIXEDFILEINFO *ffi;
1233     UINT puLen;
1234     WCHAR tmp[32];
1235
1236     TRACE("%s %p %ld %p %ld\n", debugstr_w(szFilePath),
1237           lpVersionBuf, pcchVersionBuf?*pcchVersionBuf:0,
1238           lpLangBuf, pcchLangBuf?*pcchLangBuf:0);
1239
1240     dwVerLen = GetFileVersionInfoSizeW(szFilePath, NULL);
1241     if( !dwVerLen )
1242         return GetLastError();
1243
1244     lpVer = HeapAlloc(GetProcessHeap(), 0, dwVerLen);
1245     if( !lpVer )
1246     {
1247         ret = ERROR_OUTOFMEMORY;
1248         goto end;
1249     }
1250
1251     if( !GetFileVersionInfoW(szFilePath, 0, dwVerLen, lpVer) )
1252     {
1253         ret = GetLastError();
1254         goto end;
1255     }
1256     if( lpVersionBuf && pcchVersionBuf && *pcchVersionBuf )
1257     {
1258         if( VerQueryValueW(lpVer, szVersionResource, (LPVOID*)&ffi, &puLen) &&
1259             (puLen > 0) )
1260         {
1261             wsprintfW(tmp, szVersionFormat,
1262                   HIWORD(ffi->dwFileVersionMS), LOWORD(ffi->dwFileVersionMS),
1263                   HIWORD(ffi->dwFileVersionLS), LOWORD(ffi->dwFileVersionLS));
1264             lstrcpynW(lpVersionBuf, tmp, *pcchVersionBuf);
1265             *pcchVersionBuf = lstrlenW(lpVersionBuf);
1266         }
1267         else
1268         {
1269             *lpVersionBuf = 0;
1270             *pcchVersionBuf = 0;
1271         }
1272     }
1273
1274     if( lpLangBuf && pcchLangBuf && *pcchLangBuf )
1275     {
1276         DWORD lang = GetUserDefaultLangID();
1277
1278         FIXME("Retrieve language from file\n");
1279         wsprintfW(tmp, szLangFormat, lang);
1280         lstrcpynW(lpLangBuf, tmp, *pcchLangBuf);
1281         *pcchLangBuf = lstrlenW(lpLangBuf);
1282     }
1283
1284 end:
1285     HeapFree(GetProcessHeap(), 0, lpVer);
1286     return ret;
1287 }
1288
1289
1290 /******************************************************************
1291  *      DllMain
1292  */
1293 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
1294 {
1295     switch(fdwReason)
1296     {
1297     case DLL_PROCESS_ATTACH:
1298         msi_hInstance = hinstDLL;
1299         DisableThreadLibraryCalls(hinstDLL);
1300         msi_dialog_register_class();
1301         break;
1302     case DLL_PROCESS_DETACH:
1303         msi_dialog_unregister_class();
1304         /* FIXME: Cleanup */
1305         break;
1306     }
1307     return TRUE;
1308 }
1309
1310 typedef struct tagIClassFactoryImpl
1311 {
1312     const IClassFactoryVtbl *lpVtbl;
1313 } IClassFactoryImpl;
1314
1315 static HRESULT WINAPI MsiCF_QueryInterface(LPCLASSFACTORY iface,
1316                 REFIID riid,LPVOID *ppobj)
1317 {
1318     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
1319     FIXME("%p %s %p\n",This,debugstr_guid(riid),ppobj);
1320     return E_NOINTERFACE;
1321 }
1322
1323 static ULONG WINAPI MsiCF_AddRef(LPCLASSFACTORY iface)
1324 {
1325     return 2;
1326 }
1327
1328 static ULONG WINAPI MsiCF_Release(LPCLASSFACTORY iface)
1329 {
1330     return 1;
1331 }
1332
1333 static HRESULT WINAPI MsiCF_CreateInstance(LPCLASSFACTORY iface,
1334     LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj)
1335 {
1336     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
1337
1338     FIXME("%p %p %s %p\n", This, pOuter, debugstr_guid(riid), ppobj);
1339     return E_FAIL;
1340 }
1341
1342 static HRESULT WINAPI MsiCF_LockServer(LPCLASSFACTORY iface, BOOL dolock)
1343 {
1344     IClassFactoryImpl *This = (IClassFactoryImpl *)iface;
1345
1346     FIXME("%p %d\n", This, dolock);
1347     return S_OK;
1348 }
1349
1350 static const IClassFactoryVtbl MsiCF_Vtbl =
1351 {
1352     MsiCF_QueryInterface,
1353     MsiCF_AddRef,
1354     MsiCF_Release,
1355     MsiCF_CreateInstance,
1356     MsiCF_LockServer
1357 };
1358
1359 static IClassFactoryImpl Msi_CF = { &MsiCF_Vtbl };
1360
1361 /******************************************************************
1362  * DllGetClassObject          [MSI.@]
1363  */
1364 HRESULT WINAPI MSI_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
1365 {
1366     TRACE("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
1367
1368     if( IsEqualCLSID (rclsid, &CLSID_IMsiServer) ||
1369         IsEqualCLSID (rclsid, &CLSID_IMsiServerMessage) ||
1370         IsEqualCLSID (rclsid, &CLSID_IMsiServerX1) ||
1371         IsEqualCLSID (rclsid, &CLSID_IMsiServerX2) ||
1372         IsEqualCLSID (rclsid, &CLSID_IMsiServerX3) )
1373     {
1374         *ppv = (LPVOID) &Msi_CF;
1375         return S_OK;
1376     }
1377     return CLASS_E_CLASSNOTAVAILABLE;
1378 }
1379
1380 /******************************************************************
1381  * DllGetVersion              [MSI.@]
1382  */
1383 HRESULT WINAPI MSI_DllGetVersion(DLLVERSIONINFO *pdvi)
1384 {
1385     TRACE("%p\n",pdvi);
1386
1387     if (pdvi->cbSize != sizeof(DLLVERSIONINFO))
1388         return E_INVALIDARG;
1389
1390     pdvi->dwMajorVersion = MSI_MAJORVERSION;
1391     pdvi->dwMinorVersion = MSI_MINORVERSION;
1392     pdvi->dwBuildNumber = MSI_BUILDNUMBER;
1393     pdvi->dwPlatformID = 1;
1394
1395     return S_OK;
1396 }
1397
1398 /******************************************************************
1399  * DllCanUnloadNow            [MSI.@]
1400  */
1401 BOOL WINAPI MSI_DllCanUnloadNow(void)
1402 {
1403     return S_FALSE;
1404 }
1405
1406 UINT WINAPI MsiGetFeatureUsageW(LPCWSTR szProduct, LPCWSTR szFeature,
1407                                 DWORD* pdwUseCount, WORD* pwDateUsed)
1408 {
1409     FIXME("%s %s %p %p\n",debugstr_w(szProduct), debugstr_w(szFeature),
1410           pdwUseCount, pwDateUsed);
1411     return ERROR_CALL_NOT_IMPLEMENTED;
1412 }
1413
1414 UINT WINAPI MsiGetFeatureUsageA(LPCSTR szProduct, LPCSTR szFeature,
1415                                 DWORD* pdwUseCount, WORD* pwDateUsed)
1416 {
1417     FIXME("%s %s %p %p\n", debugstr_a(szProduct), debugstr_a(szFeature),
1418           pdwUseCount, pwDateUsed);
1419     return ERROR_CALL_NOT_IMPLEMENTED;
1420 }
1421
1422 INSTALLSTATE WINAPI MsiUseFeatureExW(LPCWSTR szProduct, LPCWSTR szFeature,
1423                              DWORD dwInstallMode, DWORD dwReserved)
1424 {
1425     FIXME("%s %s %li %li\n", debugstr_w(szProduct), debugstr_w(szFeature),
1426           dwInstallMode, dwReserved);
1427
1428     /*
1429      * Polls all the components of the feature to find install state and then
1430      *  writes:
1431      *    Software\\Microsoft\\Windows\\CurrentVersion\\
1432      *    Installer\\Products\\<squishguid>\\<feature>
1433      *      "Usage"=dword:........
1434      */
1435
1436     return INSTALLSTATE_LOCAL;
1437 }
1438
1439 /***********************************************************************
1440  * MsiUseFeatureExA           [MSI.@]
1441  */
1442 INSTALLSTATE WINAPI MsiUseFeatureExA(LPCSTR szProduct, LPCSTR szFeature,
1443                              DWORD dwInstallMode, DWORD dwReserved)
1444 {
1445     FIXME("%s %s %li %li\n", debugstr_a(szProduct), debugstr_a(szFeature),
1446           dwInstallMode, dwReserved);
1447
1448     return INSTALLSTATE_LOCAL;
1449 }
1450
1451 INSTALLSTATE WINAPI MsiUseFeatureW(LPCWSTR szProduct, LPCWSTR szFeature)
1452 {
1453     FIXME("%s %s\n", debugstr_w(szProduct), debugstr_w(szFeature));
1454
1455     return INSTALLSTATE_LOCAL;
1456 }
1457
1458 INSTALLSTATE WINAPI MsiUseFeatureA(LPCSTR szProduct, LPCSTR szFeature)
1459 {
1460     FIXME("%s %s\n", debugstr_a(szProduct), debugstr_a(szFeature));
1461
1462     return INSTALLSTATE_LOCAL;
1463 }
1464
1465 UINT WINAPI MsiProvideQualifiedComponentExW(LPCWSTR szComponent,
1466                 LPCWSTR szQualifier, DWORD dwInstallMode, LPWSTR szProduct,
1467                 DWORD Unused1, DWORD Unused2, LPWSTR lpPathBuf,
1468                 DWORD* pcchPathBuf)
1469 {
1470     HKEY hkey;
1471     UINT rc;
1472     LPWSTR info;
1473     DWORD sz;
1474     LPWSTR product = NULL;
1475     LPWSTR component = NULL;
1476     LPWSTR ptr;
1477     GUID clsid;
1478
1479     TRACE("%s %s %li %s %li %li %p %p\n", debugstr_w(szComponent),
1480           debugstr_w(szQualifier), dwInstallMode, debugstr_w(szProduct),
1481           Unused1, Unused2, lpPathBuf, pcchPathBuf);
1482    
1483     rc = MSIREG_OpenUserComponentsKey(szComponent, &hkey, FALSE);
1484     if (rc != ERROR_SUCCESS)
1485         return ERROR_INDEX_ABSENT;
1486
1487     sz = 0;
1488     rc = RegQueryValueExW( hkey, szQualifier, NULL, NULL, NULL, &sz);
1489     if (sz <= 0)
1490     {
1491         RegCloseKey(hkey);
1492         return ERROR_INDEX_ABSENT;
1493     }
1494
1495     info = HeapAlloc(GetProcessHeap(),0,sz);
1496     rc = RegQueryValueExW( hkey, szQualifier, NULL, NULL, (LPBYTE)info, &sz);
1497     if (rc != ERROR_SUCCESS)
1498     {
1499         RegCloseKey(hkey);
1500         HeapFree(GetProcessHeap(),0,info);
1501         return ERROR_INDEX_ABSENT;
1502     }
1503
1504     /* find the component */
1505     ptr = strchrW(&info[20],'>');
1506     if (ptr)
1507         ptr++;
1508     else
1509     {
1510         RegCloseKey(hkey);
1511         HeapFree(GetProcessHeap(),0,info);
1512         return ERROR_INDEX_ABSENT;
1513     }
1514
1515     if (!szProduct)
1516     {
1517         decode_base85_guid(info,&clsid);
1518         StringFromCLSID(&clsid, &product);
1519     }
1520     decode_base85_guid(ptr,&clsid);
1521     StringFromCLSID(&clsid, &component);
1522
1523     if (!szProduct)
1524         rc = MsiGetComponentPathW(product, component, lpPathBuf, pcchPathBuf);
1525     else
1526         rc = MsiGetComponentPathW(szProduct, component, lpPathBuf, pcchPathBuf);
1527    
1528     RegCloseKey(hkey);
1529     HeapFree(GetProcessHeap(),0,info);
1530     HeapFree(GetProcessHeap(),0,product);
1531     HeapFree(GetProcessHeap(),0,component);
1532
1533     if (rc == INSTALLSTATE_LOCAL)
1534         return ERROR_SUCCESS;
1535     else 
1536         return ERROR_FILE_NOT_FOUND;
1537 }
1538
1539 /***********************************************************************
1540  * MsiProvideQualifiedComponentW [MSI.@]
1541  */
1542 UINT WINAPI MsiProvideQualifiedComponentW( LPCWSTR szComponent,
1543                 LPCWSTR szQualifier, DWORD dwInstallMode, LPWSTR lpPathBuf,
1544                 DWORD* pcchPathBuf)
1545 {
1546     return MsiProvideQualifiedComponentExW(szComponent, szQualifier, 
1547                     dwInstallMode, NULL, 0, 0, lpPathBuf, pcchPathBuf);
1548 }
1549
1550 /***********************************************************************
1551  * MsiProvideQualifiedComponentA [MSI.@]
1552  */
1553 UINT WINAPI MsiProvideQualifiedComponentA( LPCSTR szComponent,
1554                 LPCSTR szQualifier, DWORD dwInstallMode, LPSTR lpPathBuf,
1555                 DWORD* pcchPathBuf)
1556 {
1557     LPWSTR szwComponent, szwQualifier, lpwPathBuf;
1558     DWORD pcchwPathBuf;
1559     UINT rc;
1560
1561     TRACE("%s %s %li %p %p\n",szComponent, szQualifier,
1562                     dwInstallMode, lpPathBuf, pcchPathBuf);
1563
1564     szwComponent= strdupAtoW( szComponent);
1565     szwQualifier= strdupAtoW( szQualifier);
1566
1567     lpwPathBuf = HeapAlloc(GetProcessHeap(),0,*pcchPathBuf * sizeof(WCHAR));
1568
1569     pcchwPathBuf = *pcchPathBuf;
1570
1571     rc = MsiProvideQualifiedComponentW(szwComponent, szwQualifier, 
1572                     dwInstallMode, lpwPathBuf, &pcchwPathBuf);
1573
1574     HeapFree(GetProcessHeap(),0,szwComponent);
1575     HeapFree(GetProcessHeap(),0,szwQualifier);
1576     *pcchPathBuf = WideCharToMultiByte(CP_ACP, 0, lpwPathBuf, pcchwPathBuf,
1577                     lpPathBuf, *pcchPathBuf, NULL, NULL);
1578
1579     HeapFree(GetProcessHeap(),0,lpwPathBuf);
1580     return rc;
1581 }
1582
1583 USERINFOSTATE WINAPI MsiGetUserInfoW(LPCWSTR szProduct, LPWSTR lpUserNameBuf,
1584                 DWORD* pcchUserNameBuf, LPWSTR lpOrgNameBuf,
1585                 DWORD* pcchOrgNameBuf, LPWSTR lpSerialBuf, DWORD* pcchSerialBuf)
1586 {
1587     HKEY hkey;
1588     DWORD sz;
1589     UINT rc = ERROR_SUCCESS,rc2 = ERROR_SUCCESS;
1590     static const WCHAR szOwner[] = {'R','e','g','O','w','n','e','r',0};
1591     static const WCHAR szCompany[] = {'R','e','g','C','o','m','p','a','n','y',0};
1592     static const WCHAR szSerial[] = {'P','r','o','d','u','c','t','I','D',0};
1593
1594     TRACE("%s %p %p %p %p %p %p\n",debugstr_w(szProduct), lpUserNameBuf,
1595           pcchUserNameBuf, lpOrgNameBuf, pcchOrgNameBuf, lpSerialBuf,
1596           pcchSerialBuf);
1597
1598     rc = MSIREG_OpenUninstallKey(szProduct, &hkey, FALSE);
1599     if (rc != ERROR_SUCCESS)
1600         return USERINFOSTATE_UNKNOWN;
1601
1602     if (lpUserNameBuf)
1603     {
1604         sz = *lpUserNameBuf * sizeof(WCHAR);
1605         rc = RegQueryValueExW( hkey, szOwner, NULL, NULL, (LPBYTE)lpUserNameBuf,
1606                                &sz);
1607     }
1608     if (!lpUserNameBuf && pcchUserNameBuf)
1609     {
1610         sz = 0;
1611         rc = RegQueryValueExW( hkey, szOwner, NULL, NULL, NULL, &sz);
1612     }
1613
1614     if (pcchUserNameBuf)
1615         *pcchUserNameBuf = sz / sizeof(WCHAR);
1616
1617     if (lpOrgNameBuf)
1618     {
1619         sz = *pcchOrgNameBuf * sizeof(WCHAR);
1620         rc2 = RegQueryValueExW( hkey, szCompany, NULL, NULL, 
1621                                (LPBYTE)lpOrgNameBuf, &sz);
1622     }
1623     if (!lpOrgNameBuf && pcchOrgNameBuf)
1624     {
1625         sz = 0;
1626         rc2 = RegQueryValueExW( hkey, szCompany, NULL, NULL, NULL, &sz);
1627     }
1628
1629     if (pcchOrgNameBuf)
1630         *pcchOrgNameBuf = sz / sizeof(WCHAR);
1631
1632     if (rc != ERROR_SUCCESS && rc != ERROR_MORE_DATA && 
1633         rc2 != ERROR_SUCCESS && rc2 != ERROR_MORE_DATA)
1634     {
1635         RegCloseKey(hkey);
1636         return USERINFOSTATE_ABSENT;
1637     }
1638
1639     if (lpSerialBuf)
1640     {
1641         sz = *pcchSerialBuf * sizeof(WCHAR);
1642         RegQueryValueExW( hkey, szSerial, NULL, NULL, (LPBYTE)lpSerialBuf,
1643                                &sz);
1644     }
1645     if (!lpSerialBuf && pcchSerialBuf)
1646     {
1647         sz = 0;
1648         rc = RegQueryValueExW( hkey, szSerial, NULL, NULL, NULL, &sz);
1649     }
1650     if (pcchSerialBuf)
1651         *pcchSerialBuf = sz / sizeof(WCHAR);
1652     
1653     RegCloseKey(hkey);
1654     return USERINFOSTATE_PRESENT;
1655 }
1656
1657 USERINFOSTATE WINAPI MsiGetUserInfoA(LPCSTR szProduct, LPSTR lpUserNameBuf,
1658                 DWORD* pcchUserNameBuf, LPSTR lpOrgNameBuf,
1659                 DWORD* pcchOrgNameBuf, LPSTR lpSerialBuf, DWORD* pcchSerialBuf)
1660 {
1661     FIXME("%s %p %p %p %p %p %p\n",debugstr_a(szProduct), lpUserNameBuf,
1662           pcchUserNameBuf, lpOrgNameBuf, pcchOrgNameBuf, lpSerialBuf,
1663           pcchSerialBuf);
1664
1665     return USERINFOSTATE_UNKNOWN;
1666 }
1667
1668 UINT WINAPI MsiCollectUserInfoW(LPCWSTR szProduct)
1669 {
1670     MSIHANDLE handle;
1671     UINT rc;
1672     MSIPACKAGE *package;
1673     static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
1674
1675     TRACE("(%s)\n",debugstr_w(szProduct));
1676
1677     rc = MsiOpenProductW(szProduct,&handle);
1678     if (rc != ERROR_SUCCESS)
1679         return ERROR_INVALID_PARAMETER;
1680
1681     package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
1682     rc = ACTION_PerformUIAction(package, szFirstRun);
1683     msiobj_release( &package->hdr );
1684
1685     MsiCloseHandle(handle);
1686
1687     return rc;
1688 }
1689
1690 UINT WINAPI MsiCollectUserInfoA(LPCSTR szProduct)
1691 {
1692     MSIHANDLE handle;
1693     UINT rc;
1694     MSIPACKAGE *package;
1695     static const WCHAR szFirstRun[] = {'F','i','r','s','t','R','u','n',0};
1696
1697     TRACE("(%s)\n",debugstr_a(szProduct));
1698
1699     rc = MsiOpenProductA(szProduct,&handle);
1700     if (rc != ERROR_SUCCESS)
1701         return ERROR_INVALID_PARAMETER;
1702
1703     package = msihandle2msiinfo(handle, MSIHANDLETYPE_PACKAGE);
1704     rc = ACTION_PerformUIAction(package, szFirstRun);
1705     msiobj_release( &package->hdr );
1706
1707     MsiCloseHandle(handle);
1708
1709     return rc;
1710 }
1711
1712 UINT WINAPI MsiCreateAndVerifyInstallerDirectory(DWORD dwReserved)
1713 {
1714     WCHAR path[MAX_PATH];
1715
1716     if(dwReserved) {
1717         FIXME("Don't know how to handle argument %ld\n", dwReserved);
1718         return ERROR_CALL_NOT_IMPLEMENTED;
1719     }
1720
1721    if(!GetWindowsDirectoryW(path, MAX_PATH)) {
1722         FIXME("GetWindowsDirectory failed unexpected! Error %ld\n",
1723               GetLastError());
1724         return ERROR_CALL_NOT_IMPLEMENTED;
1725    }
1726
1727    strcatW(path, installerW);
1728
1729    CreateDirectoryW(path, NULL);
1730
1731    return 0;
1732 }
1733
1734 UINT WINAPI MsiGetShortcutTargetA( LPCSTR szShortcutTarget,
1735                                    LPSTR szProductCode, LPSTR szFeatureId,
1736                                    LPSTR szComponentCode )
1737 {
1738     FIXME("\n");
1739     return ERROR_CALL_NOT_IMPLEMENTED;
1740 }
1741
1742 UINT WINAPI MsiGetShortcutTargetW( LPCWSTR szShortcutTarget,
1743                                    LPWSTR szProductCode, LPWSTR szFeatureId,
1744                                    LPWSTR szComponentCode )
1745 {
1746     FIXME("\n");
1747     return ERROR_CALL_NOT_IMPLEMENTED;
1748 }
1749
1750 UINT WINAPI MsiReinstallFeatureW( LPCWSTR szProduct, LPCWSTR szFeature,
1751                                   DWORD dwReinstallMode )
1752 {
1753     FIXME("%s %s %li\n", debugstr_w(szProduct), debugstr_w(szFeature),
1754                            dwReinstallMode);
1755     return ERROR_SUCCESS;
1756 }
1757
1758 UINT WINAPI MsiReinstallFeatureA( LPCSTR szProduct, LPCSTR szFeature,
1759                                   DWORD dwReinstallMode )
1760 {
1761     FIXME("%s %s %li\n", debugstr_a(szProduct), debugstr_a(szFeature),
1762                            dwReinstallMode);
1763     return ERROR_SUCCESS;
1764 }