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