?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Pass an IWineD3DBaseTextureImpl pointer to basetexture_get_lod().
[wine.git] / dlls / msi / package.c
blobc7e1f986f27b6680df1fc9c7753540f68c433da1
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
3 *
4 * Copyright 2004 Aric Stewart for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define NONAMELESSUNION
22 #define NONAMELESSSTRUCT
23 #define COBJMACROS
24
25 #include <stdarg.h>
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winreg.h"
29 #include "winnls.h"
30 #include "shlwapi.h"
31 #include "wingdi.h"
32 #include "wine/debug.h"
33 #include "msi.h"
34 #include "msiquery.h"
35 #include "objidl.h"
36 #include "wincrypt.h"
37 #include "winuser.h"
38 #include "wininet.h"
39 #include "winver.h"
40 #include "urlmon.h"
41 #include "shlobj.h"
42 #include "wine/unicode.h"
43 #include "objbase.h"
44 #include "msidefs.h"
45 #include "sddl.h"
46
47 #include "msipriv.h"
48 #include "msiserver.h"
49
50 WINE_DEFAULT_DEBUG_CHANNEL(msi);
51
52 static void remove_tracked_tempfiles( MSIPACKAGE *package )
53 {
54 struct list *item, *cursor;
55
56 LIST_FOR_EACH_SAFE( item, cursor, &package->tempfiles )
57 {
58 MSITEMPFILE *temp = LIST_ENTRY( item, MSITEMPFILE, entry );
59
60 list_remove( &temp->entry );
61 TRACE("deleting temp file %s\n", debugstr_w( temp->Path ));
62 DeleteFileW( temp->Path );
63 msi_free( temp->Path );
64 msi_free( temp );
65 }
66 }
67
68 static void free_feature( MSIFEATURE *feature )
69 {
70 struct list *item, *cursor;
71
72 LIST_FOR_EACH_SAFE( item, cursor, &feature->Children )
73 {
74 FeatureList *fl = LIST_ENTRY( item, FeatureList, entry );
75 list_remove( &fl->entry );
76 msi_free( fl );
77 }
78
79 LIST_FOR_EACH_SAFE( item, cursor, &feature->Components )
80 {
81 ComponentList *cl = LIST_ENTRY( item, ComponentList, entry );
82 list_remove( &cl->entry );
83 msi_free( cl );
84 }
85 msi_free( feature->Feature );
86 msi_free( feature->Feature_Parent );
87 msi_free( feature->Directory );
88 msi_free( feature->Description );
89 msi_free( feature->Title );
90 msi_free( feature );
91 }
92
93 static void free_extension( MSIEXTENSION *ext )
94 {
95 struct list *item, *cursor;
96
97 LIST_FOR_EACH_SAFE( item, cursor, &ext->verbs )
98 {
99 MSIVERB *verb = LIST_ENTRY( item, MSIVERB, entry );
100
101 list_remove( &verb->entry );
102 msi_free( verb->Verb );
103 msi_free( verb->Command );
104 msi_free( verb->Argument );
105 msi_free( verb );
106 }
107
108 msi_free( ext->Extension );
109 msi_free( ext->ProgIDText );
110 msi_free( ext );
111 }
112
113 static void free_assembly( MSIASSEMBLY *assembly )
114 {
115 msi_free( assembly->display_name );
116 if (assembly->tempdir) RemoveDirectoryW( assembly->tempdir );
117 msi_free( assembly->tempdir );
118 msi_free( assembly );
119 }
120
121 static void free_package_structures( MSIPACKAGE *package )
122 {
123 INT i;
124 struct list *item, *cursor;
125
126 TRACE("Freeing package action data\n");
127
128 remove_tracked_tempfiles(package);
129
130 LIST_FOR_EACH_SAFE( item, cursor, &package->features )
131 {
132 MSIFEATURE *feature = LIST_ENTRY( item, MSIFEATURE, entry );
133 list_remove( &feature->entry );
134 free_feature( feature );
135 }
136
137 LIST_FOR_EACH_SAFE( item, cursor, &package->folders )
138 {
139 MSIFOLDER *folder = LIST_ENTRY( item, MSIFOLDER, entry );
140
141 list_remove( &folder->entry );
142 msi_free( folder->Parent );
143 msi_free( folder->Directory );
144 msi_free( folder->TargetDefault );
145 msi_free( folder->SourceLongPath );
146 msi_free( folder->SourceShortPath );
147 msi_free( folder->ResolvedTarget );
148 msi_free( folder->ResolvedSource );
149 msi_free( folder->Property );
150 msi_free( folder );
151 }
152
153 LIST_FOR_EACH_SAFE( item, cursor, &package->components )
154 {
155 MSICOMPONENT *comp = LIST_ENTRY( item, MSICOMPONENT, entry );
156
157 list_remove( &comp->entry );
158 msi_free( comp->Component );
159 msi_free( comp->ComponentId );
160 msi_free( comp->Directory );
161 msi_free( comp->Condition );
162 msi_free( comp->KeyPath );
163 msi_free( comp->FullKeypath );
164 if (comp->assembly) free_assembly( comp->assembly );
165 msi_free( comp );
166 }
167
168 LIST_FOR_EACH_SAFE( item, cursor, &package->files )
169 {
170 MSIFILE *file = LIST_ENTRY( item, MSIFILE, entry );
171
172 list_remove( &file->entry );
173 msi_free( file->File );
174 msi_free( file->FileName );
175 msi_free( file->ShortName );
176 msi_free( file->LongName );
177 msi_free( file->Version );
178 msi_free( file->Language );
179 msi_free( file->TargetPath );
180 msi_free( file );
181 }
182
183 /* clean up extension, progid, class and verb structures */
184 LIST_FOR_EACH_SAFE( item, cursor, &package->classes )
185 {
186 MSICLASS *cls = LIST_ENTRY( item, MSICLASS, entry );
187
188 list_remove( &cls->entry );
189 msi_free( cls->clsid );
190 msi_free( cls->Context );
191 msi_free( cls->Description );
192 msi_free( cls->FileTypeMask );
193 msi_free( cls->IconPath );
194 msi_free( cls->DefInprocHandler );
195 msi_free( cls->DefInprocHandler32 );
196 msi_free( cls->Argument );
197 msi_free( cls->ProgIDText );
198 msi_free( cls );
199 }
200
201 LIST_FOR_EACH_SAFE( item, cursor, &package->extensions )
202 {
203 MSIEXTENSION *ext = LIST_ENTRY( item, MSIEXTENSION, entry );
204
205 list_remove( &ext->entry );
206 free_extension( ext );
207 }
208
209 LIST_FOR_EACH_SAFE( item, cursor, &package->progids )
210 {
211 MSIPROGID *progid = LIST_ENTRY( item, MSIPROGID, entry );
212
213 list_remove( &progid->entry );
214 msi_free( progid->ProgID );
215 msi_free( progid->Description );
216 msi_free( progid->IconPath );
217 msi_free( progid );
218 }
219
220 LIST_FOR_EACH_SAFE( item, cursor, &package->mimes )
221 {
222 MSIMIME *mt = LIST_ENTRY( item, MSIMIME, entry );
223
224 list_remove( &mt->entry );
225 msi_free( mt->suffix );
226 msi_free( mt->clsid );
227 msi_free( mt->ContentType );
228 msi_free( mt );
229 }
230
231 LIST_FOR_EACH_SAFE( item, cursor, &package->appids )
232 {
233 MSIAPPID *appid = LIST_ENTRY( item, MSIAPPID, entry );
234
235 list_remove( &appid->entry );
236 msi_free( appid->AppID );
237 msi_free( appid->RemoteServerName );
238 msi_free( appid->LocalServer );
239 msi_free( appid->ServiceParameters );
240 msi_free( appid->DllSurrogate );
241 msi_free( appid );
242 }
243
244 LIST_FOR_EACH_SAFE( item, cursor, &package->sourcelist_info )
245 {
246 MSISOURCELISTINFO *info = LIST_ENTRY( item, MSISOURCELISTINFO, entry );
247
248 list_remove( &info->entry );
249 msi_free( info->value );
250 msi_free( info );
251 }
252
253 LIST_FOR_EACH_SAFE( item, cursor, &package->sourcelist_media )
254 {
255 MSIMEDIADISK *info = LIST_ENTRY( item, MSIMEDIADISK, entry );
256
257 list_remove( &info->entry );
258 msi_free( info->volume_label );
259 msi_free( info->disk_prompt );
260 msi_free( info );
261 }
262
263 if (package->script)
264 {
265 for (i = 0; i < TOTAL_SCRIPTS; i++)
266 msi_free_action_script( package, i );
267
268 for (i = 0; i < package->script->UniqueActionsCount; i++)
269 msi_free( package->script->UniqueActions[i] );
270
271 msi_free( package->script->UniqueActions );
272 msi_free( package->script );
273 }
274
275 LIST_FOR_EACH_SAFE( item, cursor, &package->patches )
276 {
277 MSIPATCHINFO *patch = LIST_ENTRY( item, MSIPATCHINFO, entry );
278
279 list_remove( &patch->entry );
280 msi_free( patch->patchcode );
281 msi_free( patch->transforms );
282 msi_free( patch->localfile );
283 msi_free( patch );
284 }
285
286 LIST_FOR_EACH_SAFE( item, cursor, &package->binaries )
287 {
288 MSIBINARY *binary = LIST_ENTRY( item, MSIBINARY, entry );
289
290 list_remove( &binary->entry );
291 if (binary->module)
292 FreeLibrary( binary->module );
293 if (!DeleteFileW( binary->tmpfile ))
294 ERR("failed to delete %s (%u)\n", debugstr_w(binary->tmpfile), GetLastError());
295 msi_free( binary->source );
296 msi_free( binary->tmpfile );
297 msi_free( binary );
298 }
299
300 msi_free( package->BaseURL );
301 msi_free( package->PackagePath );
302 msi_free( package->ProductCode );
303 msi_free( package->ActionFormat );
304 msi_free( package->LastAction );
305 msi_free( package->langids );
306
307 /* cleanup control event subscriptions */
308 ControlEvent_CleanupSubscriptions( package );
309 }
310
311 static void MSI_FreePackage( MSIOBJECTHDR *arg)
312 {
313 MSIPACKAGE *package= (MSIPACKAGE*) arg;
314
315 if( package->dialog )
316 msi_dialog_destroy( package->dialog );
317
318 msiobj_release( &package->db->hdr );
319 free_package_structures(package);
320 CloseHandle( package->log_file );
321
322 if (package->cache_net) IAssemblyCache_Release( package->cache_net );
323 if (package->cache_sxs) IAssemblyCache_Release( package->cache_sxs );
324 }
325
326 static UINT create_temp_property_table(MSIPACKAGE *package)
327 {
328 MSIQUERY *view = NULL;
329 UINT rc;
330
331 static const WCHAR CreateSql[] = {
332 'C','R','E','A','T','E',' ','T','A','B','L','E',' ',
333 '`','_','P','r','o','p','e','r','t','y','`',' ','(',' ',
334 '`','_','P','r','o','p','e','r','t','y','`',' ',
335 'C','H','A','R','(','5','6',')',' ','N','O','T',' ','N','U','L','L',' ',
336 'T','E','M','P','O','R','A','R','Y',',',' ',
337 '`','V','a','l','u','e','`',' ','C','H','A','R','(','9','8',')',' ',
338 'N','O','T',' ','N','U','L','L',' ','T','E','M','P','O','R','A','R','Y',
339 ' ','P','R','I','M','A','R','Y',' ','K','E','Y',' ',
340 '`','_','P','r','o','p','e','r','t','y','`',')',' ','H','O','L','D',0};
341
342 rc = MSI_DatabaseOpenViewW(package->db, CreateSql, &view);
343 if (rc != ERROR_SUCCESS)
344 return rc;
345
346 rc = MSI_ViewExecute(view, 0);
347 MSI_ViewClose(view);
348 msiobj_release(&view->hdr);
349 return rc;
350 }
351
352 UINT msi_clone_properties(MSIPACKAGE *package)
353 {
354 MSIQUERY *view_select = NULL;
355 UINT rc;
356
357 static const WCHAR query_select[] = {
358 'S','E','L','E','C','T',' ','*',' ',
359 'F','R','O','M',' ','`','P','r','o','p','e','r','t','y','`',0};
360 static const WCHAR query_insert[] = {
361 'I','N','S','E','R','T',' ','i','n','t','o',' ',
362 '`','_','P','r','o','p','e','r','t','y','`',' ',
363 '(','`','_','P','r','o','p','e','r','t','y','`',',',
364 '`','V','a','l','u','e','`',')',' ',
365 'V','A','L','U','E','S',' ','(','?',',','?',')',0};
366 static const WCHAR query_update[] = {
367 'U','P','D','A','T','E',' ','`','_','P','r','o','p','e','r','t','y','`',' ',
368 'S','E','T',' ','`','V','a','l','u','e','`',' ','=',' ','?',' ',
369 'W','H','E','R','E',' ','`','_','P','r','o','p','e','r','t','y','`',' ','=',' ','?',0};
370
371 rc = MSI_DatabaseOpenViewW( package->db, query_select, &view_select );
372 if (rc != ERROR_SUCCESS)
373 return rc;
374
375 rc = MSI_ViewExecute( view_select, 0 );
376 if (rc != ERROR_SUCCESS)
377 {
378 MSI_ViewClose( view_select );
379 msiobj_release( &view_select->hdr );
380 return rc;
381 }
382
383 while (1)
384 {
385 MSIQUERY *view_insert, *view_update;
386 MSIRECORD *rec_select;
387
388 rc = MSI_ViewFetch( view_select, &rec_select );
389 if (rc != ERROR_SUCCESS)
390 break;
391
392 rc = MSI_DatabaseOpenViewW( package->db, query_insert, &view_insert );
393 if (rc != ERROR_SUCCESS)
394 {
395 msiobj_release( &rec_select->hdr );
396 continue;
397 }
398
399 rc = MSI_ViewExecute( view_insert, rec_select );
400 MSI_ViewClose( view_insert );
401 msiobj_release( &view_insert->hdr );
402 if (rc != ERROR_SUCCESS)
403 {
404 MSIRECORD *rec_update;
405
406 TRACE("insert failed, trying update\n");
407
408 rc = MSI_DatabaseOpenViewW( package->db, query_update, &view_update );
409 if (rc != ERROR_SUCCESS)
410 {
411 WARN("open view failed %u\n", rc);
412 msiobj_release( &rec_select->hdr );
413 continue;
414 }
415
416 rec_update = MSI_CreateRecord( 2 );
417 MSI_RecordCopyField( rec_select, 1, rec_update, 2 );
418 MSI_RecordCopyField( rec_select, 2, rec_update, 1 );
419 rc = MSI_ViewExecute( view_update, rec_update );
420 if (rc != ERROR_SUCCESS)
421 WARN("update failed %u\n", rc);
422
423 MSI_ViewClose( view_update );
424 msiobj_release( &view_update->hdr );
425 msiobj_release( &rec_update->hdr );
426 }
427
428 msiobj_release( &rec_select->hdr );
429 }
430
431 MSI_ViewClose( view_select );
432 msiobj_release( &view_select->hdr );
433 return rc;
434 }
435
436 /*
437 * set_installed_prop
438 *
439 * Sets the "Installed" property to indicate that
440 * the product is installed for the current user.
441 */
442 static UINT set_installed_prop( MSIPACKAGE *package )
443 {
444 HKEY hkey = 0;
445 UINT r;
446
447 r = MSIREG_OpenUninstallKey( package, &hkey, FALSE );
448 if (r == ERROR_SUCCESS)
449 {
450 RegCloseKey( hkey );
451 msi_set_property( package->db, szInstalled, szOne );
452 }
453
454 return r;
455 }
456
457 static UINT set_user_sid_prop( MSIPACKAGE *package )
458 {
459 SID_NAME_USE use;
460 LPWSTR user_name;
461 LPWSTR sid_str = NULL, dom = NULL;
462 DWORD size, dom_size;
463 PSID psid = NULL;
464 UINT r = ERROR_FUNCTION_FAILED;
465
466 size = 0;
467 GetUserNameW( NULL, &size );
468
469 user_name = msi_alloc( (size + 1) * sizeof(WCHAR) );
470 if (!user_name)
471 return ERROR_OUTOFMEMORY;
472
473 if (!GetUserNameW( user_name, &size ))
474 goto done;
475
476 size = 0;
477 dom_size = 0;
478 LookupAccountNameW( NULL, user_name, NULL, &size, NULL, &dom_size, &use );
479
480 psid = msi_alloc( size );
481 dom = msi_alloc( dom_size*sizeof (WCHAR) );
482 if (!psid || !dom)
483 {
484 r = ERROR_OUTOFMEMORY;
485 goto done;
486 }
487
488 if (!LookupAccountNameW( NULL, user_name, psid, &size, dom, &dom_size, &use ))
489 goto done;
490
491 if (!ConvertSidToStringSidW( psid, &sid_str ))
492 goto done;
493
494 r = msi_set_property( package->db, szUserSID, sid_str );
495
496 done:
497 LocalFree( sid_str );
498 msi_free( dom );
499 msi_free( psid );
500 msi_free( user_name );
501
502 return r;
503 }
504
505 static LPWSTR get_fusion_filename(MSIPACKAGE *package)
506 {
507 HKEY netsetup;
508 LONG res;
509 LPWSTR file = NULL;
510 DWORD index = 0, size;
511 WCHAR ver[MAX_PATH];
512 WCHAR name[MAX_PATH];
513 WCHAR windir[MAX_PATH];
514
515 static const WCHAR fusion[] = {'f','u','s','i','o','n','.','d','l','l',0};
516 static const WCHAR sub[] = {
517 'S','o','f','t','w','a','r','e','\\',
518 'M','i','c','r','o','s','o','f','t','\\',
519 'N','E','T',' ','F','r','a','m','e','w','o','r','k',' ','S','e','t','u','p','\\',
520 'N','D','P',0
521 };
522 static const WCHAR subdir[] = {
523 'M','i','c','r','o','s','o','f','t','.','N','E','T','\\',
524 'F','r','a','m','e','w','o','r','k','\\',0
525 };
526
527 res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, sub, 0, KEY_ENUMERATE_SUB_KEYS, &netsetup);
528 if (res != ERROR_SUCCESS)
529 return NULL;
530
531 GetWindowsDirectoryW(windir, MAX_PATH);
532
533 ver[0] = '\0';
534 size = MAX_PATH;
535 while (RegEnumKeyExW(netsetup, index, name, &size, NULL, NULL, NULL, NULL) == ERROR_SUCCESS)
536 {
537 index++;
538
539 /* verify existence of fusion.dll .Net 3.0 does not install a new one */
540 if (strcmpW( ver, name ) < 0)
541 {
542 LPWSTR check;
543 size = lstrlenW(windir) + lstrlenW(subdir) + lstrlenW(name) +lstrlenW(fusion) + 3;
544 check = msi_alloc(size * sizeof(WCHAR));
545
546 if (!check)
547 {
548 msi_free(file);
549 return NULL;
550 }
551
552 lstrcpyW(check, windir);
553 lstrcatW(check, szBackSlash);
554 lstrcatW(check, subdir);
555 lstrcatW(check, name);
556 lstrcatW(check, szBackSlash);
557 lstrcatW(check, fusion);
558
559 if(GetFileAttributesW(check) != INVALID_FILE_ATTRIBUTES)
560 {
561 msi_free(file);
562 file = check;
563 lstrcpyW(ver, name);
564 }
565 else
566 msi_free(check);
567 }
568 }
569
570 RegCloseKey(netsetup);
571 return file;
572 }
573
574 typedef struct tagLANGANDCODEPAGE
575 {
576 WORD wLanguage;
577 WORD wCodePage;
578 } LANGANDCODEPAGE;
579
580 static void set_msi_assembly_prop(MSIPACKAGE *package)
581 {
582 UINT val_len;
583 DWORD size, handle;
584 LPVOID version = NULL;
585 WCHAR buf[MAX_PATH];
586 LPWSTR fusion, verstr;
587 LANGANDCODEPAGE *translate;
588
589 static const WCHAR netasm[] = {
590 'M','s','i','N','e','t','A','s','s','e','m','b','l','y','S','u','p','p','o','r','t',0
591 };
592 static const WCHAR translation[] = {
593 '\\','V','a','r','F','i','l','e','I','n','f','o',
594 '\\','T','r','a','n','s','l','a','t','i','o','n',0
595 };
596 static const WCHAR verfmt[] = {
597 '\\','S','t','r','i','n','g','F','i','l','e','I','n','f','o',
598 '\\','%','0','4','x','%','0','4','x',
599 '\\','P','r','o','d','u','c','t','V','e','r','s','i','o','n',0
600 };
601
602 fusion = get_fusion_filename(package);
603 if (!fusion)
604 return;
605
606 size = GetFileVersionInfoSizeW(fusion, &handle);
607 if (!size) return;
608
609 version = msi_alloc(size);
610 if (!version) return;
611
612 if (!GetFileVersionInfoW(fusion, handle, size, version))
613 goto done;
614
615 if (!VerQueryValueW(version, translation, (LPVOID *)&translate, &val_len))
616 goto done;
617
618 sprintfW(buf, verfmt, translate[0].wLanguage, translate[0].wCodePage);
619
620 if (!VerQueryValueW(version, buf, (LPVOID *)&verstr, &val_len))
621 goto done;
622
623 if (!val_len || !verstr)
624 goto done;
625
626 msi_set_property(package->db, netasm, verstr);
627
628 done:
629 msi_free(fusion);
630 msi_free(version);
631 }
632
633 static VOID set_installer_properties(MSIPACKAGE *package)
634 {
635 WCHAR pth[MAX_PATH];
636 WCHAR *ptr;
637 OSVERSIONINFOEXW OSVersion;
638 MEMORYSTATUSEX msex;
639 DWORD verval, len;
640 WCHAR verstr[10], bufstr[20];
641 HDC dc;
642 HKEY hkey;
643 LPWSTR username, companyname;
644 SYSTEM_INFO sys_info;
645 SYSTEMTIME systemtime;
646 LANGID langid;
647
648 static const WCHAR szCommonFilesFolder[] = {'C','o','m','m','o','n','F','i','l','e','s','F','o','l','d','e','r',0};
649 static const WCHAR szProgramFilesFolder[] = {'P','r','o','g','r','a','m','F','i','l','e','s','F','o','l','d','e','r',0};
650 static const WCHAR szCommonAppDataFolder[] = {'C','o','m','m','o','n','A','p','p','D','a','t','a','F','o','l','d','e','r',0};
651 static const WCHAR szFavoritesFolder[] = {'F','a','v','o','r','i','t','e','s','F','o','l','d','e','r',0};
652 static const WCHAR szFontsFolder[] = {'F','o','n','t','s','F','o','l','d','e','r',0};
653 static const WCHAR szSendToFolder[] = {'S','e','n','d','T','o','F','o','l','d','e','r',0};
654 static const WCHAR szStartMenuFolder[] = {'S','t','a','r','t','M','e','n','u','F','o','l','d','e','r',0};
655 static const WCHAR szStartupFolder[] = {'S','t','a','r','t','u','p','F','o','l','d','e','r',0};
656 static const WCHAR szTemplateFolder[] = {'T','e','m','p','l','a','t','e','F','o','l','d','e','r',0};
657 static const WCHAR szDesktopFolder[] = {'D','e','s','k','t','o','p','F','o','l','d','e','r',0};
658 static const WCHAR szProgramMenuFolder[] = {'P','r','o','g','r','a','m','M','e','n','u','F','o','l','d','e','r',0};
659 static const WCHAR szAdminToolsFolder[] = {'A','d','m','i','n','T','o','o','l','s','F','o','l','d','e','r',0};
660 static const WCHAR szAppDataFolder[] = {'A','p','p','D','a','t','a','F','o','l','d','e','r',0};
661 static const WCHAR szSystemFolder[] = {'S','y','s','t','e','m','F','o','l','d','e','r',0};
662 static const WCHAR szSystem16Folder[] = {'S','y','s','t','e','m','1','6','F','o','l','d','e','r',0};
663 static const WCHAR szLocalAppDataFolder[] = {'L','o','c','a','l','A','p','p','D','a','t','a','F','o','l','d','e','r',0};
664 static const WCHAR szMyPicturesFolder[] = {'M','y','P','i','c','t','u','r','e','s','F','o','l','d','e','r',0};
665 static const WCHAR szPersonalFolder[] = {'P','e','r','s','o','n','a','l','F','o','l','d','e','r',0};
666 static const WCHAR szWindowsFolder[] = {'W','i','n','d','o','w','s','F','o','l','d','e','r',0};
667 static const WCHAR szWindowsVolume[] = {'W','i','n','d','o','w','s','V','o','l','u','m','e',0};
668 static const WCHAR szTempFolder[]= {'T','e','m','p','F','o','l','d','e','r',0};
669 static const WCHAR szPrivileged[] = {'P','r','i','v','i','l','e','g','e','d',0};
670 static const WCHAR szVersion9x[] = {'V','e','r','s','i','o','n','9','X',0};
671 static const WCHAR szVersionNT[] = {'V','e','r','s','i','o','n','N','T',0};
672 static const WCHAR szMsiNTProductType[] = {'M','s','i','N','T','P','r','o','d','u','c','t','T','y','p','e',0};
673 static const WCHAR szFormat[] = {'%','l','i',0};
674 static const WCHAR szWindowsBuild[] = {'W','i','n','d','o','w','s','B','u','i','l','d',0};
675 static const WCHAR szServicePackLevel[] = {'S','e','r','v','i','c','e','P','a','c','k','L','e','v','e','l',0};
676 static const WCHAR szSix[] = {'6',0 };
677 static const WCHAR szVersionMsi[] = { 'V','e','r','s','i','o','n','M','s','i',0 };
678 static const WCHAR szVersionDatabase[] = { 'V','e','r','s','i','o','n','D','a','t','a','b','a','s','e',0 };
679 static const WCHAR szPhysicalMemory[] = { 'P','h','y','s','i','c','a','l','M','e','m','o','r','y',0 };
680 static const WCHAR szFormat2[] = {'%','l','i','.','%','l','i',0};
681 static const WCHAR szScreenX[] = {'S','c','r','e','e','n','X',0};
682 static const WCHAR szScreenY[] = {'S','c','r','e','e','n','Y',0};
683 static const WCHAR szColorBits[] = {'C','o','l','o','r','B','i','t','s',0};
684 static const WCHAR szIntFormat[] = {'%','d',0};
685 static const WCHAR szMsiAMD64[] = { 'M','s','i','A','M','D','6','4',0 };
686 static const WCHAR szMsix64[] = { 'M','s','i','x','6','4',0 };
687 static const WCHAR szSystem64Folder[] = { 'S','y','s','t','e','m','6','4','F','o','l','d','e','r',0 };
688 static const WCHAR szCommonFiles64Folder[] = { 'C','o','m','m','o','n','F','i','l','e','s','6','4','F','o','l','d','e','r',0 };
689 static const WCHAR szProgramFiles64Folder[] = { 'P','r','o','g','r','a','m','F','i','l','e','s','6','4','F','o','l','d','e','r',0 };
690 static const WCHAR szVersionNT64[] = { 'V','e','r','s','i','o','n','N','T','6','4',0 };
691 static const WCHAR szUserInfo[] = {
692 'S','O','F','T','W','A','R','E','\\',
693 'M','i','c','r','o','s','o','f','t','\\',
694 'M','S',' ','S','e','t','u','p',' ','(','A','C','M','E',')','\\',
695 'U','s','e','r',' ','I','n','f','o',0
696 };
697 static const WCHAR szDefName[] = { 'D','e','f','N','a','m','e',0 };
698 static const WCHAR szDefCompany[] = { 'D','e','f','C','o','m','p','a','n','y',0 };
699 static const WCHAR szCurrentVersion[] = {
700 'S','O','F','T','W','A','R','E','\\',
701 'M','i','c','r','o','s','o','f','t','\\',
702 'W','i','n','d','o','w','s',' ','N','T','\\',
703 'C','u','r','r','e','n','t','V','e','r','s','i','o','n',0
704 };
705 static const WCHAR szRegisteredUser[] = {'R','e','g','i','s','t','e','r','e','d','O','w','n','e','r',0};
706 static const WCHAR szRegisteredOrganization[] = {
707 'R','e','g','i','s','t','e','r','e','d','O','r','g','a','n','i','z','a','t','i','o','n',0
708 };
709 static const WCHAR szUSERNAME[] = {'U','S','E','R','N','A','M','E',0};
710 static const WCHAR szCOMPANYNAME[] = {'C','O','M','P','A','N','Y','N','A','M','E',0};
711 static const WCHAR szDate[] = {'D','a','t','e',0};
712 static const WCHAR szTime[] = {'T','i','m','e',0};
713 static const WCHAR szUserLanguageID[] = {'U','s','e','r','L','a','n','g','u','a','g','e','I','D',0};
714 static const WCHAR szSystemLangID[] = {'S','y','s','t','e','m','L','a','n','g','u','a','g','e','I','D',0};
715 static const WCHAR szProductState[] = {'P','r','o','d','u','c','t','S','t','a','t','e',0};
716 static const WCHAR szLogonUser[] = {'L','o','g','o','n','U','s','e','r',0};
717 static const WCHAR szNetHoodFolder[] = {'N','e','t','H','o','o','d','F','o','l','d','e','r',0};
718 static const WCHAR szPrintHoodFolder[] = {'P','r','i','n','t','H','o','o','d','F','o','l','d','e','r',0};
719 static const WCHAR szRecentFolder[] = {'R','e','c','e','n','t','F','o','l','d','e','r',0};
720
721 /*
722 * Other things that probably should be set:
723 *
724 * ComputerName VirtualMemory
725 * ShellAdvSupport DefaultUIFont PackagecodeChanging
726 * CaptionHeight BorderTop BorderSide TextHeight
727 * RedirectedDllSupport
728 */
729
730 SHGetFolderPathW(NULL, CSIDL_COMMON_APPDATA, NULL, 0, pth);
731 strcatW(pth, szBackSlash);
732 msi_set_property(package->db, szCommonAppDataFolder, pth);
733
734 SHGetFolderPathW(NULL, CSIDL_FAVORITES, NULL, 0, pth);
735 strcatW(pth, szBackSlash);
736 msi_set_property(package->db, szFavoritesFolder, pth);
737
738 SHGetFolderPathW(NULL, CSIDL_FONTS, NULL, 0, pth);
739 strcatW(pth, szBackSlash);
740 msi_set_property(package->db, szFontsFolder, pth);
741
742 SHGetFolderPathW(NULL, CSIDL_SENDTO, NULL, 0, pth);
743 strcatW(pth, szBackSlash);
744 msi_set_property(package->db, szSendToFolder, pth);
745
746 SHGetFolderPathW(NULL, CSIDL_STARTMENU, NULL, 0, pth);
747 strcatW(pth, szBackSlash);
748 msi_set_property(package->db, szStartMenuFolder, pth);
749
750 SHGetFolderPathW(NULL, CSIDL_STARTUP, NULL, 0, pth);
751 strcatW(pth, szBackSlash);
752 msi_set_property(package->db, szStartupFolder, pth);
753
754 SHGetFolderPathW(NULL, CSIDL_TEMPLATES, NULL, 0, pth);
755 strcatW(pth, szBackSlash);
756 msi_set_property(package->db, szTemplateFolder, pth);
757
758 SHGetFolderPathW(NULL, CSIDL_DESKTOP, NULL, 0, pth);
759 strcatW(pth, szBackSlash);
760 msi_set_property(package->db, szDesktopFolder, pth);
761
762 /* FIXME: set to AllUsers profile path if ALLUSERS is set */
763 SHGetFolderPathW(NULL, CSIDL_PROGRAMS, NULL, 0, pth);
764 strcatW(pth, szBackSlash);
765 msi_set_property(package->db, szProgramMenuFolder, pth);
766
767 SHGetFolderPathW(NULL, CSIDL_ADMINTOOLS, NULL, 0, pth);
768 strcatW(pth, szBackSlash);
769 msi_set_property(package->db, szAdminToolsFolder, pth);
770
771 SHGetFolderPathW(NULL, CSIDL_APPDATA, NULL, 0, pth);
772 strcatW(pth, szBackSlash);
773 msi_set_property(package->db, szAppDataFolder, pth);
774
775 SHGetFolderPathW(NULL, CSIDL_SYSTEM, NULL, 0, pth);
776 strcatW(pth, szBackSlash);
777 msi_set_property(package->db, szSystemFolder, pth);
778 msi_set_property(package->db, szSystem16Folder, pth);
779
780 SHGetFolderPathW(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, pth);
781 strcatW(pth, szBackSlash);
782 msi_set_property(package->db, szLocalAppDataFolder, pth);
783
784 SHGetFolderPathW(NULL, CSIDL_MYPICTURES, NULL, 0, pth);
785 strcatW(pth, szBackSlash);
786 msi_set_property(package->db, szMyPicturesFolder, pth);
787
788 SHGetFolderPathW(NULL, CSIDL_PERSONAL, NULL, 0, pth);
789 strcatW(pth, szBackSlash);
790 msi_set_property(package->db, szPersonalFolder, pth);
791
792 SHGetFolderPathW(NULL, CSIDL_WINDOWS, NULL, 0, pth);
793 strcatW(pth, szBackSlash);
794 msi_set_property(package->db, szWindowsFolder, pth);
795
796 SHGetFolderPathW(NULL, CSIDL_PRINTHOOD, NULL, 0, pth);
797 strcatW(pth, szBackSlash);
798 msi_set_property(package->db, szPrintHoodFolder, pth);
799
800 SHGetFolderPathW(NULL, CSIDL_NETHOOD, NULL, 0, pth);
801 strcatW(pth, szBackSlash);
802 msi_set_property(package->db, szNetHoodFolder, pth);
803
804 SHGetFolderPathW(NULL, CSIDL_RECENT, NULL, 0, pth);
805 strcatW(pth, szBackSlash);
806 msi_set_property(package->db, szRecentFolder, pth);
807
808 /* Physical Memory is specified in MB. Using total amount. */
809 msex.dwLength = sizeof(msex);
810 GlobalMemoryStatusEx( &msex );
811 sprintfW( bufstr, szIntFormat, (int)(msex.ullTotalPhys / 1024 / 1024) );
812 msi_set_property(package->db, szPhysicalMemory, bufstr);
813
814 SHGetFolderPathW(NULL, CSIDL_WINDOWS, NULL, 0, pth);
815 ptr = strchrW(pth,'\\');
816 if (ptr) *(ptr + 1) = 0;
817 msi_set_property(package->db, szWindowsVolume, pth);
818
819 GetTempPathW(MAX_PATH,pth);
820 msi_set_property(package->db, szTempFolder, pth);
821
822 /* in a wine environment the user is always admin and privileged */
823 msi_set_property(package->db, szAdminUser, szOne);
824 msi_set_property(package->db, szPrivileged, szOne);
825
826 /* set the os things */
827 OSVersion.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXW);
828 GetVersionExW((OSVERSIONINFOW *)&OSVersion);
829 verval = OSVersion.dwMinorVersion + OSVersion.dwMajorVersion * 100;
830 sprintfW(verstr, szFormat, verval);
831 switch (OSVersion.dwPlatformId)
832 {
833 case VER_PLATFORM_WIN32_WINDOWS:
834 msi_set_property(package->db, szVersion9x, verstr);
835 break;
836 case VER_PLATFORM_WIN32_NT:
837 msi_set_property(package->db, szVersionNT, verstr);
838 sprintfW(verstr, szFormat,OSVersion.wProductType);
839 msi_set_property(package->db, szMsiNTProductType, verstr);
840 break;
841 }
842 sprintfW(verstr, szFormat, OSVersion.dwBuildNumber);
843 msi_set_property(package->db, szWindowsBuild, verstr);
844 /* just fudge this */
845 msi_set_property(package->db, szServicePackLevel, szSix);
846
847 sprintfW( bufstr, szFormat2, MSI_MAJORVERSION, MSI_MINORVERSION);
848 msi_set_property( package->db, szVersionMsi, bufstr );
849 sprintfW( bufstr, szFormat, MSI_MAJORVERSION * 100);
850 msi_set_property( package->db, szVersionDatabase, bufstr );
851
852 GetNativeSystemInfo( &sys_info );
853 sprintfW( bufstr, szIntFormat, sys_info.wProcessorLevel );
854 if (sys_info.u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL)
855 {
856 msi_set_property( package->db, szIntel, bufstr );
857
858 GetSystemDirectoryW( pth, MAX_PATH );
859 PathAddBackslashW( pth );
860 msi_set_property( package->db, szSystemFolder, pth );
861
862 SHGetFolderPathW( NULL, CSIDL_PROGRAM_FILES, NULL, 0, pth );
863 PathAddBackslashW( pth );
864 msi_set_property( package->db, szProgramFilesFolder, pth );
865
866 SHGetFolderPathW( NULL, CSIDL_PROGRAM_FILES_COMMON, NULL, 0, pth );
867 PathAddBackslashW( pth );
868 msi_set_property( package->db, szCommonFilesFolder, pth );
869 }
870 else if (sys_info.u.s.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
871 {
872 msi_set_property( package->db, szMsiAMD64, bufstr );
873 msi_set_property( package->db, szMsix64, bufstr );
874 msi_set_property( package->db, szVersionNT64, verstr );
875
876 GetSystemDirectoryW( pth, MAX_PATH );
877 PathAddBackslashW( pth );
878 msi_set_property( package->db, szSystem64Folder, pth );
879
880 GetSystemWow64DirectoryW( pth, MAX_PATH );
881 PathAddBackslashW( pth );
882 msi_set_property( package->db, szSystemFolder, pth );
883
884 SHGetFolderPathW( NULL, CSIDL_PROGRAM_FILES, NULL, 0, pth );
885 PathAddBackslashW( pth );
886 msi_set_property( package->db, szProgramFiles64Folder, pth );
887
888 SHGetFolderPathW( NULL, CSIDL_PROGRAM_FILESX86, NULL, 0, pth );
889 PathAddBackslashW( pth );
890 msi_set_property( package->db, szProgramFilesFolder, pth );
891
892 SHGetFolderPathW( NULL, CSIDL_PROGRAM_FILES_COMMON, NULL, 0, pth );
893 PathAddBackslashW( pth );
894 msi_set_property( package->db, szCommonFiles64Folder, pth );
895
896 SHGetFolderPathW( NULL, CSIDL_PROGRAM_FILES_COMMONX86, NULL, 0, pth );
897 PathAddBackslashW( pth );
898 msi_set_property( package->db, szCommonFilesFolder, pth );
899 }
900
901 /* Screen properties. */
902 dc = GetDC(0);
903 sprintfW( bufstr, szIntFormat, GetDeviceCaps( dc, HORZRES ) );
904 msi_set_property( package->db, szScreenX, bufstr );
905 sprintfW( bufstr, szIntFormat, GetDeviceCaps( dc, VERTRES ));
906 msi_set_property( package->db, szScreenY, bufstr );
907 sprintfW( bufstr, szIntFormat, GetDeviceCaps( dc, BITSPIXEL ));
908 msi_set_property( package->db, szColorBits, bufstr );
909 ReleaseDC(0, dc);
910
911 /* USERNAME and COMPANYNAME */
912 username = msi_dup_property( package->db, szUSERNAME );
913 companyname = msi_dup_property( package->db, szCOMPANYNAME );
914
915 if ((!username || !companyname) &&
916 RegOpenKeyW( HKEY_CURRENT_USER, szUserInfo, &hkey ) == ERROR_SUCCESS)
917 {
918 if (!username &&
919 (username = msi_reg_get_val_str( hkey, szDefName )))
920 msi_set_property( package->db, szUSERNAME, username );
921 if (!companyname &&
922 (companyname = msi_reg_get_val_str( hkey, szDefCompany )))
923 msi_set_property( package->db, szCOMPANYNAME, companyname );
924 CloseHandle( hkey );
925 }
926 if ((!username || !companyname) &&
927 RegOpenKeyW( HKEY_LOCAL_MACHINE, szCurrentVersion, &hkey ) == ERROR_SUCCESS)
928 {
929 if (!username &&
930 (username = msi_reg_get_val_str( hkey, szRegisteredUser )))
931 msi_set_property( package->db, szUSERNAME, username );
932 if (!companyname &&
933 (companyname = msi_reg_get_val_str( hkey, szRegisteredOrganization )))
934 msi_set_property( package->db, szCOMPANYNAME, companyname );
935 CloseHandle( hkey );
936 }
937 msi_free( username );
938 msi_free( companyname );
939
940 if ( set_user_sid_prop( package ) != ERROR_SUCCESS)
941 ERR("Failed to set the UserSID property\n");
942
943 /* Date and time properties */
944 GetSystemTime( &systemtime );
945 if (GetDateFormatW( LOCALE_USER_DEFAULT, DATE_SHORTDATE, &systemtime,
946 NULL, bufstr, sizeof(bufstr)/sizeof(bufstr[0]) ))
947 msi_set_property( package->db, szDate, bufstr );
948 else
949 ERR("Couldn't set Date property: GetDateFormat failed with error %d\n", GetLastError());
950
951 if (GetTimeFormatW( LOCALE_USER_DEFAULT,
952 TIME_FORCE24HOURFORMAT | TIME_NOTIMEMARKER,
953 &systemtime, NULL, bufstr,
954 sizeof(bufstr)/sizeof(bufstr[0]) ))
955 msi_set_property( package->db, szTime, bufstr );
956 else
957 ERR("Couldn't set Time property: GetTimeFormat failed with error %d\n", GetLastError());
958
959 set_msi_assembly_prop( package );
960
961 langid = GetUserDefaultLangID();
962 sprintfW(bufstr, szIntFormat, langid);
963 msi_set_property( package->db, szUserLanguageID, bufstr );
964
965 langid = GetSystemDefaultLangID();
966 sprintfW(bufstr, szIntFormat, langid);
967 msi_set_property( package->db, szSystemLangID, bufstr );
968
969 sprintfW(bufstr, szIntFormat, MsiQueryProductStateW(package->ProductCode));
970 msi_set_property( package->db, szProductState, bufstr );
971
972 len = 0;
973 if (!GetUserNameW( NULL, &len ) && GetLastError() == ERROR_MORE_DATA)
974 {
975 WCHAR *username;
976 if ((username = msi_alloc( len * sizeof(WCHAR) )))
977 {
978 if (GetUserNameW( username, &len ))
979 msi_set_property( package->db, szLogonUser, username );
980 msi_free( username );
981 }
982 }
983 }
984
985 static UINT msi_load_summary_properties( MSIPACKAGE *package )
986 {
987 UINT rc;
988 MSIHANDLE suminfo;
989 MSIHANDLE hdb = alloc_msihandle( &package->db->hdr );
990 INT count;
991 DWORD len;
992 LPWSTR package_code;
993 static const WCHAR szPackageCode[] = {
994 'P','a','c','k','a','g','e','C','o','d','e',0};
995
996 if (!hdb) {
997 ERR("Unable to allocate handle\n");
998 return ERROR_OUTOFMEMORY;
999 }
1000
1001 rc = MsiGetSummaryInformationW( hdb, NULL, 0, &suminfo );
1002 MsiCloseHandle(hdb);
1003 if (rc != ERROR_SUCCESS)
1004 {
1005 ERR("Unable to open Summary Information\n");
1006 return rc;
1007 }
1008
1009 rc = MsiSummaryInfoGetPropertyW( suminfo, PID_PAGECOUNT, NULL,
1010 &count, NULL, NULL, NULL );
1011 if (rc != ERROR_SUCCESS)
1012 {
1013 WARN("Unable to query page count: %d\n", rc);
1014 goto done;
1015 }
1016
1017 /* load package code property */
1018 len = 0;
1019 rc = MsiSummaryInfoGetPropertyW( suminfo, PID_REVNUMBER, NULL,
1020 NULL, NULL, NULL, &len );
1021 if (rc != ERROR_MORE_DATA)
1022 {
1023 WARN("Unable to query revision number: %d\n", rc);
1024 rc = ERROR_FUNCTION_FAILED;
1025 goto done;
1026 }
1027
1028 len++;
1029 package_code = msi_alloc( len * sizeof(WCHAR) );
1030 rc = MsiSummaryInfoGetPropertyW( suminfo, PID_REVNUMBER, NULL,
1031 NULL, NULL, package_code, &len );
1032 if (rc != ERROR_SUCCESS)
1033 {
1034 WARN("Unable to query rev number: %d\n", rc);
1035 goto done;
1036 }
1037
1038 msi_set_property( package->db, szPackageCode, package_code );
1039 msi_free( package_code );
1040
1041 /* load package attributes */
1042 count = 0;
1043 MsiSummaryInfoGetPropertyW( suminfo, PID_WORDCOUNT, NULL,
1044 &count, NULL, NULL, NULL );
1045 package->WordCount = count;
1046
1047 done:
1048 MsiCloseHandle(suminfo);
1049 return rc;
1050 }
1051
1052 static MSIPACKAGE *msi_alloc_package( void )
1053 {
1054 MSIPACKAGE *package;
1055
1056 package = alloc_msiobject( MSIHANDLETYPE_PACKAGE, sizeof (MSIPACKAGE),
1057 MSI_FreePackage );
1058 if( package )
1059 {
1060 list_init( &package->components );
1061 list_init( &package->features );
1062 list_init( &package->files );
1063 list_init( &package->tempfiles );
1064 list_init( &package->folders );
1065 list_init( &package->subscriptions );
1066 list_init( &package->appids );
1067 list_init( &package->classes );
1068 list_init( &package->mimes );
1069 list_init( &package->extensions );
1070 list_init( &package->progids );
1071 list_init( &package->RunningActions );
1072 list_init( &package->sourcelist_info );
1073 list_init( &package->sourcelist_media );
1074 list_init( &package->patches );
1075 list_init( &package->binaries );
1076 }
1077
1078 return package;
1079 }
1080
1081 static UINT msi_load_admin_properties(MSIPACKAGE *package)
1082 {
1083 BYTE *data;
1084 UINT r, sz;
1085
1086 static const WCHAR stmname[] = {'A','d','m','i','n','P','r','o','p','e','r','t','i','e','s',0};
1087
1088 r = read_stream_data(package->db->storage, stmname, FALSE, &data, &sz);
1089 if (r != ERROR_SUCCESS)
1090 return r;
1091
1092 r = msi_parse_command_line(package, (WCHAR *)data, TRUE);
1093
1094 msi_free(data);
1095 return r;
1096 }
1097
1098 void msi_adjust_privilege_properties( MSIPACKAGE *package )
1099 {
1100 /* FIXME: this should depend on the user's privileges */
1101 if (msi_get_property_int( package->db, szAllUsers, 0 ) == 2)
1102 {
1103 TRACE("resetting ALLUSERS property from 2 to 1\n");
1104 msi_set_property( package->db, szAllUsers, szOne );
1105 }
1106 msi_set_property( package->db, szAdminUser, szOne );
1107 }
1108
1109 MSIPACKAGE *MSI_CreatePackage( MSIDATABASE *db, LPCWSTR base_url )
1110 {
1111 static const WCHAR szLevel[] = { 'U','I','L','e','v','e','l',0 };
1112 static const WCHAR szpi[] = {'%','i',0};
1113 MSIPACKAGE *package;
1114 WCHAR uilevel[10];
1115 UINT r;
1116
1117 TRACE("%p\n", db);
1118
1119 package = msi_alloc_package();
1120 if (package)
1121 {
1122 msiobj_addref( &db->hdr );
1123 package->db = db;
1124
1125 package->WordCount = 0;
1126 package->PackagePath = strdupW( db->path );
1127 package->BaseURL = strdupW( base_url );
1128
1129 create_temp_property_table( package );
1130 msi_clone_properties( package );
1131 msi_adjust_privilege_properties( package );
1132
1133 package->ProductCode = msi_dup_property( package->db, szProductCode );
1134 package->script = msi_alloc_zero( sizeof(MSISCRIPT) );
1135
1136 set_installed_prop( package );
1137 set_installer_properties( package );
1138
1139 sprintfW(uilevel,szpi,gUILevel);
1140 msi_set_property(package->db, szLevel, uilevel);
1141
1142 r = msi_load_summary_properties( package );
1143 if (r != ERROR_SUCCESS)
1144 {
1145 msiobj_release( &package->hdr );
1146 return NULL;
1147 }
1148
1149 if (package->WordCount & msidbSumInfoSourceTypeAdminImage)
1150 msi_load_admin_properties( package );
1151
1152 package->log_file = INVALID_HANDLE_VALUE;
1153 }
1154
1155 return package;
1156 }
1157
1158 /*
1159 * copy_package_to_temp [internal]
1160 *
1161 * copy the msi file to a temp file to prevent locking a CD
1162 * with a multi disc install
1163 *
1164 * FIXME: I think this is wrong, and instead of copying the package,
1165 * we should read all the tables to memory, then open the
1166 * database to read binary streams on demand.
1167 */
1168 static UINT copy_package_to_temp( LPCWSTR szPackage, LPWSTR filename )
1169 {
1170 WCHAR path[MAX_PATH];
1171
1172 GetTempPathW( MAX_PATH, path );
1173 GetTempFileNameW( path, szMsi, 0, filename );
1174
1175 if( !CopyFileW( szPackage, filename, FALSE ) )
1176 {
1177 UINT error = GetLastError();
1178 if ( error == ERROR_FILE_NOT_FOUND )
1179 ERR("can't find %s\n", debugstr_w(szPackage));
1180 else
1181 ERR("failed to copy package %s to %s (%u)\n", debugstr_w(szPackage), debugstr_w(filename), error);
1182 DeleteFileW( filename );
1183 return error;
1184 }
1185
1186 return ERROR_SUCCESS;
1187 }
1188
1189 UINT msi_download_file( LPCWSTR szUrl, LPWSTR filename )
1190 {
1191 LPINTERNET_CACHE_ENTRY_INFOW cache_entry;
1192 DWORD size = 0;
1193 HRESULT hr;
1194
1195 /* call will always fail, becase size is 0,
1196 * but will return ERROR_FILE_NOT_FOUND first
1197 * if the file doesn't exist
1198 */
1199 GetUrlCacheEntryInfoW( szUrl, NULL, &size );
1200 if ( GetLastError() != ERROR_FILE_NOT_FOUND )
1201 {
1202 cache_entry = msi_alloc( size );
1203 if ( !GetUrlCacheEntryInfoW( szUrl, cache_entry, &size ) )
1204 {
1205 UINT error = GetLastError();
1206 msi_free( cache_entry );
1207 return error;
1208 }
1209
1210 lstrcpyW( filename, cache_entry->lpszLocalFileName );
1211 msi_free( cache_entry );
1212 return ERROR_SUCCESS;
1213 }
1214
1215 hr = URLDownloadToCacheFileW( NULL, szUrl, filename, MAX_PATH, 0, NULL );
1216 if ( FAILED(hr) )
1217 {
1218 WARN("failed to download %s to cache file\n", debugstr_w(szUrl));
1219 return ERROR_FUNCTION_FAILED;
1220 }
1221
1222 return ERROR_SUCCESS;
1223 }
1224
1225 UINT msi_get_local_package_name( LPWSTR path, LPCWSTR suffix )
1226 {
1227 static const WCHAR szInstaller[] = {
1228 '\\','I','n','s','t','a','l','l','e','r','\\',0};
1229 static const WCHAR fmt[] = {'%','x',0};
1230 DWORD time, len, i, offset;
1231 HANDLE handle;
1232
1233 time = GetTickCount();
1234 GetWindowsDirectoryW( path, MAX_PATH );
1235 strcatW( path, szInstaller );
1236 CreateDirectoryW( path, NULL );
1237
1238 len = strlenW(path);
1239 for (i = 0; i < 0x10000; i++)
1240 {
1241 offset = snprintfW( path + len, MAX_PATH - len, fmt, (time + i) & 0xffff );
1242 memcpy( path + len + offset, suffix, (strlenW( suffix ) + 1) * sizeof(WCHAR) );
1243 handle = CreateFileW( path, GENERIC_WRITE, 0, NULL,
1244 CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
1245 if (handle != INVALID_HANDLE_VALUE)
1246 {
1247 CloseHandle(handle);
1248 break;
1249 }
1250 if (GetLastError() != ERROR_FILE_EXISTS &&
1251 GetLastError() != ERROR_SHARING_VIOLATION)
1252 return ERROR_FUNCTION_FAILED;
1253 }
1254
1255 return ERROR_SUCCESS;
1256 }
1257
1258 static UINT apply_registered_patch( MSIPACKAGE *package, LPCWSTR patch_code )
1259 {
1260 UINT r;
1261 DWORD len;
1262 WCHAR patch_file[MAX_PATH];
1263 MSIDATABASE *patch_db;
1264 MSIPATCHINFO *patch_info;
1265 MSISUMMARYINFO *si;
1266
1267 len = sizeof(patch_file) / sizeof(WCHAR);
1268 r = MsiGetPatchInfoExW( patch_code, package->ProductCode, NULL, package->Context,
1269 INSTALLPROPERTY_LOCALPACKAGEW, patch_file, &len );
1270 if (r != ERROR_SUCCESS)
1271 {
1272 ERR("failed to get patch filename %u\n", r);
1273 return r;
1274 }
1275
1276 r = MSI_OpenDatabaseW( patch_file, MSIDBOPEN_READONLY + MSIDBOPEN_PATCHFILE, &patch_db );
1277 if (r != ERROR_SUCCESS)
1278 {
1279 ERR("failed to open patch database %s\n", debugstr_w( patch_file ));
1280 return r;
1281 }
1282
1283 si = MSI_GetSummaryInformationW( patch_db->storage, 0 );
1284 if (!si)
1285 {
1286 msiobj_release( &patch_db->hdr );
1287 return ERROR_FUNCTION_FAILED;
1288 }
1289
1290 r = msi_parse_patch_summary( si, &patch_info );
1291 msiobj_release( &si->hdr );
1292 if (r != ERROR_SUCCESS)
1293 {
1294 ERR("failed to parse patch summary %u\n", r);
1295 msiobj_release( &patch_db->hdr );
1296 return r;
1297 }
1298
1299 patch_info->localfile = strdupW( patch_file );
1300 if (!patch_info->localfile)
1301 {
1302 msiobj_release( &patch_db->hdr );
1303 return ERROR_OUTOFMEMORY;
1304 }
1305
1306 r = msi_apply_patch_db( package, patch_db, patch_info );
1307 msiobj_release( &patch_db->hdr );
1308 if (r != ERROR_SUCCESS)
1309 {
1310 ERR("failed to apply patch %u\n", r);
1311 msi_free( patch_info->patchcode );
1312 msi_free( patch_info->transforms );
1313 msi_free( patch_info->localfile );
1314 msi_free( patch_info );
1315 }
1316 return r;
1317 }
1318
1319 static UINT msi_parse_summary( MSISUMMARYINFO *si, MSIPACKAGE *package )
1320 {
1321 WCHAR *template, *p, *q;
1322 DWORD i, count;
1323
1324 package->version = msi_suminfo_get_int32( si, PID_PAGECOUNT );
1325 TRACE("version: %d\n", package->version);
1326
1327 template = msi_suminfo_dup_string( si, PID_TEMPLATE );
1328 if (!template)
1329 return ERROR_SUCCESS; /* native accepts missing template property */
1330
1331 TRACE("template: %s\n", debugstr_w(template));
1332
1333 p = strchrW( template, ';' );
1334 if (!p)
1335 {
1336 WARN("invalid template string %s\n", debugstr_w(template));
1337 msi_free( template );
1338 return ERROR_PATCH_PACKAGE_INVALID;
1339 }
1340 *p = 0;
1341 if (!template[0] || !strcmpW( template, szIntel ))
1342 package->platform = PLATFORM_INTEL;
1343 else if (!strcmpW( template, szIntel64 ))
1344 package->platform = PLATFORM_INTEL64;
1345 else if (!strcmpW( template, szX64 ) || !strcmpW( template, szAMD64 ))
1346 package->platform = PLATFORM_X64;
1347 else
1348 {
1349 WARN("unknown platform %s\n", debugstr_w(template));
1350 msi_free( template );
1351 return ERROR_INSTALL_PLATFORM_UNSUPPORTED;
1352 }
1353 p++;
1354 if (!*p)
1355 {
1356 msi_free( template );
1357 return ERROR_SUCCESS;
1358 }
1359 count = 1;
1360 for (q = p; (q = strchrW( q, ',' )); q++) count++;
1361
1362 package->langids = msi_alloc( count * sizeof(LANGID) );
1363 if (!package->langids)
1364 {
1365 msi_free( template );
1366 return ERROR_OUTOFMEMORY;
1367 }
1368
1369 i = 0;
1370 while (*p)
1371 {
1372 q = strchrW( p, ',' );
1373 if (q) *q = 0;
1374 package->langids[i] = atoiW( p );
1375 if (!q) break;
1376 p = q + 1;
1377 i++;
1378 }
1379 package->num_langids = i + 1;
1380
1381 msi_free( template );
1382 return ERROR_SUCCESS;
1383 }
1384
1385 static UINT validate_package( MSIPACKAGE *package )
1386 {
1387 BOOL is_wow64;
1388 UINT i;
1389
1390 IsWow64Process( GetCurrentProcess(), &is_wow64 );
1391 if (package->platform == PLATFORM_X64)
1392 {
1393 if (!is_64bit && !is_wow64)
1394 return ERROR_INSTALL_PLATFORM_UNSUPPORTED;
1395 if (package->version < 200)
1396 return ERROR_INSTALL_PACKAGE_INVALID;
1397 }
1398 if (!package->num_langids)
1399 {
1400 return ERROR_SUCCESS;
1401 }
1402 for (i = 0; i < package->num_langids; i++)
1403 {
1404 LANGID langid = package->langids[i];
1405
1406 if (PRIMARYLANGID( langid ) == LANG_NEUTRAL)
1407 {
1408 langid = MAKELANGID( PRIMARYLANGID( GetSystemDefaultLangID() ), SUBLANGID( langid ) );
1409 }
1410 if (SUBLANGID( langid ) == SUBLANG_NEUTRAL)
1411 {
1412 langid = MAKELANGID( PRIMARYLANGID( langid ), SUBLANGID( GetSystemDefaultLangID() ) );
1413 }
1414 if (IsValidLocale( langid, LCID_INSTALLED ))
1415 return ERROR_SUCCESS;
1416 }
1417 return ERROR_INSTALL_LANGUAGE_UNSUPPORTED;
1418 }
1419
1420 UINT MSI_OpenPackageW(LPCWSTR szPackage, MSIPACKAGE **pPackage)
1421 {
1422 static const WCHAR Database[] = {'D','A','T','A','B','A','S','E',0};
1423 static const WCHAR dotmsi[] = {'.','m','s','i',0};
1424 MSIDATABASE *db = NULL;
1425 MSIPACKAGE *package;
1426 MSIHANDLE handle;
1427 LPWSTR ptr, base_url = NULL;
1428 UINT r;
1429 WCHAR temppath[MAX_PATH], localfile[MAX_PATH], cachefile[MAX_PATH];
1430 LPCWSTR file = szPackage;
1431 DWORD index = 0;
1432 MSISUMMARYINFO *si;
1433
1434 TRACE("%s %p\n", debugstr_w(szPackage), pPackage);
1435
1436 if( szPackage[0] == '#' )
1437 {
1438 handle = atoiW(&szPackage[1]);
1439 db = msihandle2msiinfo( handle, MSIHANDLETYPE_DATABASE );
1440 if( !db )
1441 {
1442 IWineMsiRemoteDatabase *remote_database;
1443
1444 remote_database = (IWineMsiRemoteDatabase *)msi_get_remote( handle );
1445 if ( !remote_database )
1446 return ERROR_INVALID_HANDLE;
1447
1448 IWineMsiRemoteDatabase_Release( remote_database );
1449 WARN("MsiOpenPackage not allowed during a custom action!\n");
1450
1451 return ERROR_FUNCTION_FAILED;
1452 }
1453 }
1454 else
1455 {
1456 if ( UrlIsW( szPackage, URLIS_URL ) )
1457 {
1458 r = msi_download_file( szPackage, cachefile );
1459 if ( r != ERROR_SUCCESS )
1460 return r;
1461
1462 r = copy_package_to_temp( cachefile, temppath );
1463 if ( r != ERROR_SUCCESS )
1464 return r;
1465
1466 file = temppath;
1467
1468 base_url = strdupW( szPackage );
1469 if ( !base_url )
1470 return ERROR_OUTOFMEMORY;
1471
1472 ptr = strrchrW( base_url, '/' );
1473 if (ptr) *(ptr + 1) = '\0';
1474 }
1475 else
1476 {
1477 r = copy_package_to_temp( szPackage, temppath );
1478 if ( r != ERROR_SUCCESS )
1479 return r;
1480
1481 file = temppath;
1482 }
1483
1484 r = msi_get_local_package_name( localfile, dotmsi );
1485 if (r != ERROR_SUCCESS)
1486 return r;
1487
1488 TRACE("Copying to local package %s\n", debugstr_w(localfile));
1489
1490 if (!CopyFileW( file, localfile, FALSE ))
1491 {
1492 ERR("Unable to copy package (%s -> %s) (error %u)\n",
1493 debugstr_w(file), debugstr_w(localfile), GetLastError());
1494 return GetLastError();
1495 }
1496
1497 TRACE("Opening relocated package %s\n", debugstr_w( file ));
1498
1499 /* transforms that add binary streams require that we open the database
1500 * read/write, which is safe because we always create a copy that is thrown
1501 * away when we're done.
1502 */
1503 r = MSI_OpenDatabaseW( file, MSIDBOPEN_TRANSACT, &db );
1504 if( r != ERROR_SUCCESS )
1505 {
1506 if (file != szPackage)
1507 DeleteFileW( file );
1508
1509 if (GetFileAttributesW(szPackage) == INVALID_FILE_ATTRIBUTES)
1510 return ERROR_FILE_NOT_FOUND;
1511
1512 return r;
1513 }
1514
1515 db->localfile = strdupW( localfile );
1516 }
1517
1518 package = MSI_CreatePackage( db, base_url );
1519 msi_free( base_url );
1520 msiobj_release( &db->hdr );
1521 if( !package )
1522 {
1523 if (file != szPackage)
1524 DeleteFileW( file );
1525
1526 return ERROR_INSTALL_PACKAGE_INVALID;
1527 }
1528
1529 if( file != szPackage )
1530 track_tempfile( package, file );
1531
1532 si = MSI_GetSummaryInformationW( db->storage, 0 );
1533 if (!si)
1534 {
1535 WARN("failed to load summary info %u\n", r);
1536 msiobj_release( &package->hdr );
1537 return ERROR_INSTALL_PACKAGE_INVALID;
1538 }
1539
1540 r = msi_parse_summary( si, package );
1541 msiobj_release( &si->hdr );
1542 if (r != ERROR_SUCCESS)
1543 {
1544 WARN("failed to parse summary info %u\n", r);
1545 msiobj_release( &package->hdr );
1546 return r;
1547 }
1548
1549 r = validate_package( package );
1550 if (r != ERROR_SUCCESS)
1551 {
1552 msiobj_release( &package->hdr );
1553 return r;
1554 }
1555 msi_set_property( package->db, Database, db->path );
1556
1557 if( UrlIsW( szPackage, URLIS_URL ) )
1558 msi_set_property( package->db, szOriginalDatabase, szPackage );
1559 else if( szPackage[0] == '#' )
1560 msi_set_property( package->db, szOriginalDatabase, db->path );
1561 else
1562 {
1563 WCHAR fullpath[MAX_PATH];
1564
1565 GetFullPathNameW( szPackage, MAX_PATH, fullpath, NULL );
1566 msi_set_property( package->db, szOriginalDatabase, fullpath );
1567 }
1568
1569 msi_set_context( package );
1570
1571 while (1)
1572 {
1573 WCHAR patch_code[GUID_SIZE];
1574 r = MsiEnumPatchesExW( package->ProductCode, NULL, package->Context,
1575 MSIPATCHSTATE_APPLIED, index, patch_code, NULL, NULL, NULL, NULL );
1576 if (r != ERROR_SUCCESS)
1577 break;
1578
1579 TRACE("found registered patch %s\n", debugstr_w(patch_code));
1580
1581 r = apply_registered_patch( package, patch_code );
1582 if (r != ERROR_SUCCESS)
1583 {
1584 ERR("registered patch failed to apply %u\n", r);
1585 msiobj_release( &package->hdr );
1586 return r;
1587 }
1588
1589 index++;
1590 }
1591
1592 if (index)
1593 {
1594 msi_clone_properties( package );
1595 msi_adjust_privilege_properties( package );
1596 }
1597
1598 if (gszLogFile)
1599 package->log_file = CreateFileW( gszLogFile, GENERIC_WRITE, FILE_SHARE_WRITE, NULL,
1600 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
1601
1602 *pPackage = package;
1603 return ERROR_SUCCESS;
1604 }
1605
1606 UINT WINAPI MsiOpenPackageExW(LPCWSTR szPackage, DWORD dwOptions, MSIHANDLE *phPackage)
1607 {
1608 MSIPACKAGE *package = NULL;
1609 UINT ret;
1610
1611 TRACE("%s %08x %p\n", debugstr_w(szPackage), dwOptions, phPackage );
1612
1613 if( !szPackage || !phPackage )
1614 return ERROR_INVALID_PARAMETER;
1615
1616 if ( !*szPackage )
1617 {
1618 FIXME("Should create an empty database and package\n");
1619 return ERROR_FUNCTION_FAILED;
1620 }
1621
1622 if( dwOptions )
1623 FIXME("dwOptions %08x not supported\n", dwOptions);
1624
1625 ret = MSI_OpenPackageW( szPackage, &package );
1626 if( ret == ERROR_SUCCESS )
1627 {
1628 *phPackage = alloc_msihandle( &package->hdr );
1629 if (! *phPackage)
1630 ret = ERROR_NOT_ENOUGH_MEMORY;
1631 msiobj_release( &package->hdr );
1632 }
1633
1634 return ret;
1635 }
1636
1637 UINT WINAPI MsiOpenPackageW(LPCWSTR szPackage, MSIHANDLE *phPackage)
1638 {
1639 return MsiOpenPackageExW( szPackage, 0, phPackage );
1640 }
1641
1642 UINT WINAPI MsiOpenPackageExA(LPCSTR szPackage, DWORD dwOptions, MSIHANDLE *phPackage)
1643 {
1644 LPWSTR szwPack = NULL;
1645 UINT ret;
1646
1647 if( szPackage )
1648 {
1649 szwPack = strdupAtoW( szPackage );
1650 if( !szwPack )
1651 return ERROR_OUTOFMEMORY;
1652 }
1653
1654 ret = MsiOpenPackageExW( szwPack, dwOptions, phPackage );
1655
1656 msi_free( szwPack );
1657
1658 return ret;
1659 }
1660
1661 UINT WINAPI MsiOpenPackageA(LPCSTR szPackage, MSIHANDLE *phPackage)
1662 {
1663 return MsiOpenPackageExA( szPackage, 0, phPackage );
1664 }
1665
1666 MSIHANDLE WINAPI MsiGetActiveDatabase(MSIHANDLE hInstall)
1667 {
1668 MSIPACKAGE *package;
1669 MSIHANDLE handle = 0;
1670 IUnknown *remote_unk;
1671 IWineMsiRemotePackage *remote_package;
1672
1673 TRACE("(%d)\n",hInstall);
1674
1675 package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE);
1676 if( package)
1677 {
1678 handle = alloc_msihandle( &package->db->hdr );
1679 msiobj_release( &package->hdr );
1680 }
1681 else if ((remote_unk = msi_get_remote(hInstall)))
1682 {
1683 if (IUnknown_QueryInterface(remote_unk, &IID_IWineMsiRemotePackage,
1684 (LPVOID *)&remote_package) == S_OK)
1685 {
1686 IWineMsiRemotePackage_GetActiveDatabase(remote_package, &handle);
1687 IWineMsiRemotePackage_Release(remote_package);
1688 }
1689 else
1690 {
1691 WARN("remote handle %d is not a package\n", hInstall);
1692 }
1693 IUnknown_Release(remote_unk);
1694 }
1695
1696 return handle;
1697 }
1698
1699 INT MSI_ProcessMessage( MSIPACKAGE *package, INSTALLMESSAGE eMessageType,
1700 MSIRECORD *record)
1701 {
1702 static const WCHAR szActionData[] =
1703 {'A','c','t','i','o','n','D','a','t','a',0};
1704 static const WCHAR szSetProgress[] =
1705 {'S','e','t','P','r','o','g','r','e','s','s',0};
1706 static const WCHAR szActionText[] =
1707 {'A','c','t','i','o','n','T','e','x','t',0};
1708 LPWSTR message;
1709 DWORD sz, total_size = 0, log_type = 0;
1710 INT i, rc = 0;
1711 char *msg;
1712 int len;
1713
1714 TRACE("%x\n", eMessageType);
1715
1716 if ((eMessageType & 0xff000000) == INSTALLMESSAGE_ERROR)
1717 log_type |= INSTALLLOGMODE_ERROR;
1718 if ((eMessageType & 0xff000000) == INSTALLMESSAGE_WARNING)
1719 log_type |= INSTALLLOGMODE_WARNING;
1720 if ((eMessageType & 0xff000000) == INSTALLMESSAGE_USER)
1721 log_type |= INSTALLLOGMODE_USER;
1722 if ((eMessageType & 0xff000000) == INSTALLMESSAGE_INFO)
1723 log_type |= INSTALLLOGMODE_INFO;
1724 if ((eMessageType & 0xff000000) == INSTALLMESSAGE_COMMONDATA)
1725 log_type |= INSTALLLOGMODE_COMMONDATA;
1726 if ((eMessageType & 0xff000000) == INSTALLMESSAGE_ACTIONSTART)
1727 log_type |= INSTALLLOGMODE_ACTIONSTART;
1728 if ((eMessageType & 0xff000000) == INSTALLMESSAGE_ACTIONDATA)
1729 log_type |= INSTALLLOGMODE_ACTIONDATA;
1730 /* just a guess */
1731 if ((eMessageType & 0xff000000) == INSTALLMESSAGE_PROGRESS)
1732 log_type |= 0x800;
1733
1734 if ((eMessageType & 0xff000000) == INSTALLMESSAGE_ACTIONSTART)
1735 {
1736 static const WCHAR template_s[]=
1737 {'A','c','t','i','o','n',' ','%','s',':',' ','%','s','.',' ',0};
1738 static const WCHAR format[] =
1739 {'H','H','\'',':','\'','m','m','\'',':','\'','s','s',0};
1740 WCHAR timet[0x100];
1741 LPCWSTR action_text, action;
1742 LPWSTR deformatted = NULL;
1743
1744 GetTimeFormatW(LOCALE_USER_DEFAULT, 0, NULL, format, timet, 0x100);
1745
1746 action = MSI_RecordGetString(record, 1);
1747 action_text = MSI_RecordGetString(record, 2);
1748
1749 if (!action || !action_text)
1750 return IDOK;
1751
1752 deformat_string(package, action_text, &deformatted);
1753
1754 len = strlenW(timet) + strlenW(action) + strlenW(template_s);
1755 if (deformatted)
1756 len += strlenW(deformatted);
1757 message = msi_alloc(len*sizeof(WCHAR));
1758 sprintfW(message, template_s, timet, action);
1759 if (deformatted)
1760 strcatW(message, deformatted);
1761 msi_free(deformatted);
1762 }
1763 else
1764 {
1765 INT msg_field=1;
1766 message = msi_alloc(1*sizeof (WCHAR));
1767 message[0]=0;
1768 msg_field = MSI_RecordGetFieldCount(record);
1769 for (i = 1; i <= msg_field; i++)
1770 {
1771 LPWSTR tmp;
1772 WCHAR number[3];
1773 static const WCHAR format[] = { '%','i',':',' ',0};
1774 sz = 0;
1775 MSI_RecordGetStringW(record,i,NULL,&sz);
1776 sz+=4;
1777 total_size+=sz*sizeof(WCHAR);
1778 tmp = msi_alloc(sz*sizeof(WCHAR));
1779 message = msi_realloc(message,total_size*sizeof (WCHAR));
1780
1781 MSI_RecordGetStringW(record,i,tmp,&sz);
1782
1783 if (msg_field > 1)
1784 {
1785 sprintfW(number,format,i);
1786 strcatW(message,number);
1787 }
1788 strcatW(message,tmp);
1789 if (msg_field > 1)
1790 strcatW(message, szSpace);
1791
1792 msi_free(tmp);
1793 }
1794 }
1795
1796 TRACE("%p %p %p %x %x %s\n", gUIHandlerA, gUIHandlerW, gUIHandlerRecord,
1797 gUIFilter, log_type, debugstr_w(message));
1798
1799 /* convert it to ASCII */
1800 len = WideCharToMultiByte( CP_ACP, 0, message, -1, NULL, 0, NULL, NULL );
1801 msg = msi_alloc( len );
1802 WideCharToMultiByte( CP_ACP, 0, message, -1, msg, len, NULL, NULL );
1803
1804 if (gUIHandlerW && (gUIFilter & log_type))
1805 {
1806 rc = gUIHandlerW( gUIContext, eMessageType, message );
1807 }
1808 else if (gUIHandlerA && (gUIFilter & log_type))
1809 {
1810 rc = gUIHandlerA( gUIContext, eMessageType, msg );
1811 }
1812 else if (gUIHandlerRecord && (gUIFilter & log_type))
1813 {
1814 MSIHANDLE rec = MsiCreateRecord( 1 );
1815 MsiRecordSetStringW( rec, 0, message );
1816 rc = gUIHandlerRecord( gUIContext, eMessageType, rec );
1817 MsiCloseHandle( rec );
1818 }
1819
1820 if (!rc && package->log_file != INVALID_HANDLE_VALUE &&
1821 (eMessageType & 0xff000000) != INSTALLMESSAGE_PROGRESS)
1822 {
1823 DWORD written;
1824 WriteFile( package->log_file, msg, len - 1, &written, NULL );
1825 WriteFile( package->log_file, "\n", 1, &written, NULL );
1826 }
1827 msi_free( msg );
1828 msi_free( message );
1829
1830 switch (eMessageType & 0xff000000)
1831 {
1832 case INSTALLMESSAGE_ACTIONDATA:
1833 /* FIXME: format record here instead of in ui_actiondata to get the
1834 * correct action data for external scripts */
1835 ControlEvent_FireSubscribedEvent(package, szActionData, record);
1836 break;
1837 case INSTALLMESSAGE_ACTIONSTART:
1838 {
1839 MSIRECORD *uirow;
1840 LPWSTR deformated;
1841 LPCWSTR action_text = MSI_RecordGetString(record, 2);
1842
1843 deformat_string(package, action_text, &deformated);
1844 uirow = MSI_CreateRecord(1);
1845 MSI_RecordSetStringW(uirow, 1, deformated);
1846 TRACE("INSTALLMESSAGE_ACTIONSTART: %s\n", debugstr_w(deformated));
1847 msi_free(deformated);
1848
1849 ControlEvent_FireSubscribedEvent(package, szActionText, uirow);
1850
1851 msiobj_release(&uirow->hdr);
1852 break;
1853 }
1854 case INSTALLMESSAGE_PROGRESS:
1855 ControlEvent_FireSubscribedEvent(package, szSetProgress, record);
1856 break;
1857 }
1858
1859 return ERROR_SUCCESS;
1860 }
1861
1862 INT WINAPI MsiProcessMessage( MSIHANDLE hInstall, INSTALLMESSAGE eMessageType,
1863 MSIHANDLE hRecord)
1864 {
1865 UINT ret = ERROR_INVALID_HANDLE;
1866 MSIPACKAGE *package = NULL;
1867 MSIRECORD *record = NULL;
1868
1869 package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE );
1870 if( !package )
1871 {
1872 HRESULT hr;
1873 IWineMsiRemotePackage *remote_package;
1874
1875 remote_package = (IWineMsiRemotePackage *)msi_get_remote( hInstall );
1876 if (!remote_package)
1877 return ERROR_INVALID_HANDLE;
1878
1879 hr = IWineMsiRemotePackage_ProcessMessage( remote_package, eMessageType, hRecord );
1880
1881 IWineMsiRemotePackage_Release( remote_package );
1882
1883 if (FAILED(hr))
1884 {
1885 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
1886 return HRESULT_CODE(hr);
1887
1888 return ERROR_FUNCTION_FAILED;
1889 }
1890
1891 return ERROR_SUCCESS;
1892 }
1893
1894 record = msihandle2msiinfo( hRecord, MSIHANDLETYPE_RECORD );
1895 if( !record )
1896 goto out;
1897
1898 ret = MSI_ProcessMessage( package, eMessageType, record );
1899
1900 out:
1901 msiobj_release( &package->hdr );
1902 if( record )
1903 msiobj_release( &record->hdr );
1904
1905 return ret;
1906 }
1907
1908 /* property code */
1909
1910 UINT WINAPI MsiSetPropertyA( MSIHANDLE hInstall, LPCSTR szName, LPCSTR szValue )
1911 {
1912 LPWSTR szwName = NULL, szwValue = NULL;
1913 UINT r = ERROR_OUTOFMEMORY;
1914
1915 szwName = strdupAtoW( szName );
1916 if( szName && !szwName )
1917 goto end;
1918
1919 szwValue = strdupAtoW( szValue );
1920 if( szValue && !szwValue )
1921 goto end;
1922
1923 r = MsiSetPropertyW( hInstall, szwName, szwValue);
1924
1925 end:
1926 msi_free( szwName );
1927 msi_free( szwValue );
1928
1929 return r;
1930 }
1931
1932 void msi_reset_folders( MSIPACKAGE *package, BOOL source )
1933 {
1934 MSIFOLDER *folder;
1935
1936 LIST_FOR_EACH_ENTRY( folder, &package->folders, MSIFOLDER, entry )
1937 {
1938 if ( source )
1939 {
1940 msi_free( folder->ResolvedSource );
1941 folder->ResolvedSource = NULL;
1942 }
1943 else
1944 {
1945 msi_free( folder->ResolvedTarget );
1946 folder->ResolvedTarget = NULL;
1947 }
1948 }
1949 }
1950
1951 UINT msi_set_property( MSIDATABASE *db, LPCWSTR szName, LPCWSTR szValue )
1952 {
1953 MSIQUERY *view;
1954 MSIRECORD *row = NULL;
1955 UINT rc;
1956 DWORD sz = 0;
1957 WCHAR Query[1024];
1958
1959 static const WCHAR Insert[] = {
1960 'I','N','S','E','R','T',' ','i','n','t','o',' ',
1961 '`','_','P','r','o','p','e','r','t','y','`',' ','(',
1962 '`','_','P','r','o','p','e','r','t','y','`',',',
1963 '`','V','a','l','u','e','`',')',' ','V','A','L','U','E','S'
1964 ,' ','(','?',',','?',')',0};
1965 static const WCHAR Update[] = {
1966 'U','P','D','A','T','E',' ','`','_','P','r','o','p','e','r','t','y','`',
1967 ' ','s','e','t',' ','`','V','a','l','u','e','`',' ','=',' ','?',' ',
1968 'w','h','e','r','e',' ','`','_','P','r','o','p','e','r','t','y','`',
1969 ' ','=',' ','\'','%','s','\'',0};
1970 static const WCHAR Delete[] = {
1971 'D','E','L','E','T','E',' ','F','R','O','M',' ',
1972 '`','_','P','r','o','p','e','r','t','y','`',' ','W','H','E','R','E',' ',
1973 '`','_','P','r','o','p','e','r','t','y','`',' ','=',' ','\'','%','s','\'',0};
1974
1975 TRACE("%p %s %s\n", db, debugstr_w(szName), debugstr_w(szValue));
1976
1977 if (!szName)
1978 return ERROR_INVALID_PARAMETER;
1979
1980 /* this one is weird... */
1981 if (!szName[0])
1982 return szValue ? ERROR_FUNCTION_FAILED : ERROR_SUCCESS;
1983
1984 rc = msi_get_property(db, szName, 0, &sz);
1985 if (!szValue || !*szValue)
1986 {
1987 sprintfW(Query, Delete, szName);
1988 }
1989 else if (rc == ERROR_MORE_DATA || rc == ERROR_SUCCESS)
1990 {
1991 sprintfW(Query, Update, szName);
1992
1993 row = MSI_CreateRecord(1);
1994 MSI_RecordSetStringW(row, 1, szValue);
1995 }
1996 else
1997 {
1998 strcpyW(Query, Insert);
1999
2000 row = MSI_CreateRecord(2);
2001 MSI_RecordSetStringW(row, 1, szName);
2002 MSI_RecordSetStringW(row, 2, szValue);
2003 }
2004
2005 rc = MSI_DatabaseOpenViewW(db, Query, &view);
2006 if (rc == ERROR_SUCCESS)
2007 {
2008 rc = MSI_ViewExecute(view, row);
2009 MSI_ViewClose(view);
2010 msiobj_release(&view->hdr);
2011 }
2012
2013 if (row)
2014 msiobj_release(&row->hdr);
2015
2016 return rc;
2017 }
2018
2019 UINT WINAPI MsiSetPropertyW( MSIHANDLE hInstall, LPCWSTR szName, LPCWSTR szValue)
2020 {
2021 MSIPACKAGE *package;
2022 UINT ret;
2023
2024 package = msihandle2msiinfo( hInstall, MSIHANDLETYPE_PACKAGE);
2025 if( !package )
2026 {
2027 HRESULT hr;
2028 BSTR name = NULL, value = NULL;
2029 IWineMsiRemotePackage *remote_package;
2030
2031 remote_package = (IWineMsiRemotePackage *)msi_get_remote( hInstall );
2032 if (!remote_package)
2033 return ERROR_INVALID_HANDLE;
2034
2035 name = SysAllocString( szName );
2036 value = SysAllocString( szValue );
2037 if ((!name && szName) || (!value && szValue))
2038 {
2039 SysFreeString( name );
2040 SysFreeString( value );
2041 IWineMsiRemotePackage_Release( remote_package );
2042 return ERROR_OUTOFMEMORY;
2043 }
2044
2045 hr = IWineMsiRemotePackage_SetProperty( remote_package, name, value );
2046
2047 SysFreeString( name );
2048 SysFreeString( value );
2049 IWineMsiRemotePackage_Release( remote_package );
2050
2051 if (FAILED(hr))
2052 {
2053 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
2054 return HRESULT_CODE(hr);
2055
2056 return ERROR_FUNCTION_FAILED;
2057 }
2058
2059 return ERROR_SUCCESS;
2060 }
2061
2062 ret = msi_set_property( package->db, szName, szValue );
2063 if (ret == ERROR_SUCCESS && !strcmpW( szName, cszSourceDir ))
2064 msi_reset_folders( package, TRUE );
2065
2066 msiobj_release( &package->hdr );
2067 return ret;
2068 }
2069
2070 static MSIRECORD *msi_get_property_row( MSIDATABASE *db, LPCWSTR name )
2071 {
2072 MSIQUERY *view;
2073 MSIRECORD *rec, *row = NULL;
2074 UINT r;
2075
2076 static const WCHAR query[]= {
2077 'S','E','L','E','C','T',' ','`','V','a','l','u','e','`',' ',
2078 'F','R','O','M',' ' ,'`','_','P','r','o','p','e','r','t','y','`',
2079 ' ','W','H','E','R','E',' ' ,'`','_','P','r','o','p','e','r','t','y','`',
2080 '=','?',0};
2081
2082 if (!name || !*name)
2083 return NULL;
2084
2085 rec = MSI_CreateRecord(1);
2086 if (!rec)
2087 return NULL;
2088
2089 MSI_RecordSetStringW(rec, 1, name);
2090
2091 r = MSI_DatabaseOpenViewW(db, query, &view);
2092 if (r == ERROR_SUCCESS)
2093 {
2094 MSI_ViewExecute(view, rec);
2095 MSI_ViewFetch(view, &row);
2096 MSI_ViewClose(view);
2097 msiobj_release(&view->hdr);
2098 }
2099
2100 msiobj_release(&rec->hdr);
2101 return row;
2102 }
2103
2104 /* internal function, not compatible with MsiGetPropertyW */
2105 UINT msi_get_property( MSIDATABASE *db, LPCWSTR szName,
2106 LPWSTR szValueBuf, LPDWORD pchValueBuf )
2107 {
2108 MSIRECORD *row;
2109 UINT rc = ERROR_FUNCTION_FAILED;
2110
2111 row = msi_get_property_row( db, szName );
2112
2113 if (*pchValueBuf > 0)
2114 szValueBuf[0] = 0;
2115
2116 if (row)
2117 {
2118 rc = MSI_RecordGetStringW(row, 1, szValueBuf, pchValueBuf);
2119 msiobj_release(&row->hdr);
2120 }
2121
2122 if (rc == ERROR_SUCCESS)
2123 TRACE("returning %s for property %s\n", debugstr_w(szValueBuf),
2124 debugstr_w(szName));
2125 else if (rc == ERROR_MORE_DATA)
2126 TRACE("need %d sized buffer for %s\n", *pchValueBuf,
2127 debugstr_w(szName));
2128 else
2129 {
2130 *pchValueBuf = 0;
2131 TRACE("property %s not found\n", debugstr_w(szName));
2132 }
2133
2134 return rc;
2135 }
2136
2137 LPWSTR msi_dup_property(MSIDATABASE *db, LPCWSTR prop)
2138 {
2139 DWORD sz = 0;
2140 LPWSTR str;
2141 UINT r;
2142
2143 r = msi_get_property(db, prop, NULL, &sz);
2144 if (r != ERROR_SUCCESS && r != ERROR_MORE_DATA)
2145 return NULL;
2146
2147 sz++;
2148 str = msi_alloc(sz * sizeof(WCHAR));
2149 r = msi_get_property(db, prop, str, &sz);
2150 if (r != ERROR_SUCCESS)
2151 {
2152 msi_free(str);
2153 str = NULL;
2154 }
2155
2156 return str;
2157 }
2158
2159 int msi_get_property_int( MSIDATABASE *db, LPCWSTR prop, int def )
2160 {
2161 LPWSTR str = msi_dup_property( db, prop );
2162 int val = str ? atoiW(str) : def;
2163 msi_free(str);
2164 return val;
2165 }
2166
2167 static UINT MSI_GetProperty( MSIHANDLE handle, LPCWSTR name,
2168 awstring *szValueBuf, LPDWORD pchValueBuf )
2169 {
2170 MSIPACKAGE *package;
2171 MSIRECORD *row = NULL;
2172 UINT r = ERROR_FUNCTION_FAILED;
2173 LPCWSTR val = NULL;
2174
2175 TRACE("%u %s %p %p\n", handle, debugstr_w(name),
2176 szValueBuf->str.w, pchValueBuf );
2177
2178 if (!name)
2179 return ERROR_INVALID_PARAMETER;
2180
2181 package = msihandle2msiinfo( handle, MSIHANDLETYPE_PACKAGE );
2182 if (!package)
2183 {
2184 HRESULT hr;
2185 IWineMsiRemotePackage *remote_package;
2186 LPWSTR value = NULL;
2187 BSTR bname;
2188 DWORD len;
2189
2190 remote_package = (IWineMsiRemotePackage *)msi_get_remote( handle );
2191 if (!remote_package)
2192 return ERROR_INVALID_HANDLE;
2193
2194 bname = SysAllocString( name );
2195 if (!bname)
2196 {
2197 IWineMsiRemotePackage_Release( remote_package );
2198 return ERROR_OUTOFMEMORY;
2199 }
2200
2201 len = 0;
2202 hr = IWineMsiRemotePackage_GetProperty( remote_package, bname, NULL, &len );
2203 if (FAILED(hr))
2204 goto done;
2205
2206 len++;
2207 value = msi_alloc(len * sizeof(WCHAR));
2208 if (!value)
2209 {
2210 r = ERROR_OUTOFMEMORY;
2211 goto done;
2212 }
2213
2214 hr = IWineMsiRemotePackage_GetProperty( remote_package, bname, (BSTR *)value, &len );
2215 if (FAILED(hr))
2216 goto done;
2217
2218 r = msi_strcpy_to_awstring( value, szValueBuf, pchValueBuf );
2219
2220 /* Bug required by Adobe installers */
2221 if (!szValueBuf->unicode && !szValueBuf->str.a)
2222 *pchValueBuf *= sizeof(WCHAR);
2223
2224 done:
2225 IWineMsiRemotePackage_Release(remote_package);
2226 SysFreeString(bname);
2227 msi_free(value);
2228
2229 if (FAILED(hr))
2230 {
2231 if (HRESULT_FACILITY(hr) == FACILITY_WIN32)
2232 return HRESULT_CODE(hr);
2233
2234 return ERROR_FUNCTION_FAILED;
2235 }
2236
2237 return r;
2238 }
2239
2240 row = msi_get_property_row( package->db, name );
2241 if (row)
2242 val = MSI_RecordGetString( row, 1 );
2243
2244 if (!val)
2245 val = szEmpty;
2246
2247 r = msi_strcpy_to_awstring( val, szValueBuf, pchValueBuf );
2248
2249 if (row)
2250 msiobj_release( &row->hdr );
2251 msiobj_release( &package->hdr );
2252
2253 return r;
2254 }
2255
2256 UINT WINAPI MsiGetPropertyA( MSIHANDLE hInstall, LPCSTR szName,
2257 LPSTR szValueBuf, LPDWORD pchValueBuf )
2258 {
2259 awstring val;
2260 LPWSTR name;
2261 UINT r;
2262
2263 val.unicode = FALSE;
2264 val.str.a = szValueBuf;
2265
2266 name = strdupAtoW( szName );
2267 if (szName && !name)
2268 return ERROR_OUTOFMEMORY;
2269
2270 r = MSI_GetProperty( hInstall, name, &val, pchValueBuf );
2271 msi_free( name );
2272 return r;
2273 }
2274
2275 UINT WINAPI MsiGetPropertyW( MSIHANDLE hInstall, LPCWSTR szName,
2276 LPWSTR szValueBuf, LPDWORD pchValueBuf )
2277 {
2278 awstring val;
2279
2280 val.unicode = TRUE;
2281 val.str.w = szValueBuf;
2282
2283 return MSI_GetProperty( hInstall, szName, &val, pchValueBuf );
2284 }
2285
2286 typedef struct _msi_remote_package_impl {
2287 IWineMsiRemotePackage IWineMsiRemotePackage_iface;
2288 MSIHANDLE package;
2289 LONG refs;
2290 } msi_remote_package_impl;
2291
2292 static inline msi_remote_package_impl *impl_from_IWineMsiRemotePackage( IWineMsiRemotePackage *iface )
2293 {
2294 return CONTAINING_RECORD(iface, msi_remote_package_impl, IWineMsiRemotePackage_iface);
2295 }
2296
2297 static HRESULT WINAPI mrp_QueryInterface( IWineMsiRemotePackage *iface,
2298 REFIID riid,LPVOID *ppobj)
2299 {
2300 if( IsEqualCLSID( riid, &IID_IUnknown ) ||
2301 IsEqualCLSID( riid, &IID_IWineMsiRemotePackage ) )
2302 {
2303 IUnknown_AddRef( iface );
2304 *ppobj = iface;
2305 return S_OK;
2306 }
2307
2308 return E_NOINTERFACE;
2309 }
2310
2311 static ULONG WINAPI mrp_AddRef( IWineMsiRemotePackage *iface )
2312 {
2313 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2314
2315 return InterlockedIncrement( &This->refs );
2316 }
2317
2318 static ULONG WINAPI mrp_Release( IWineMsiRemotePackage *iface )
2319 {
2320 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2321 ULONG r;
2322
2323 r = InterlockedDecrement( &This->refs );
2324 if (r == 0)
2325 {
2326 MsiCloseHandle( This->package );
2327 msi_free( This );
2328 }
2329 return r;
2330 }
2331
2332 static HRESULT WINAPI mrp_SetMsiHandle( IWineMsiRemotePackage *iface, MSIHANDLE handle )
2333 {
2334 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2335 This->package = handle;
2336 return S_OK;
2337 }
2338
2339 static HRESULT WINAPI mrp_GetActiveDatabase( IWineMsiRemotePackage *iface, MSIHANDLE *handle )
2340 {
2341 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2342 IWineMsiRemoteDatabase *rdb = NULL;
2343 HRESULT hr;
2344 MSIHANDLE hdb;
2345
2346 hr = create_msi_remote_database( NULL, (LPVOID *)&rdb );
2347 if (FAILED(hr) || !rdb)
2348 {
2349 ERR("Failed to create remote database\n");
2350 return hr;
2351 }
2352
2353 hdb = MsiGetActiveDatabase(This->package);
2354
2355 hr = IWineMsiRemoteDatabase_SetMsiHandle( rdb, hdb );
2356 if (FAILED(hr))
2357 {
2358 ERR("Failed to set the database handle\n");
2359 return hr;
2360 }
2361
2362 *handle = alloc_msi_remote_handle( (IUnknown *)rdb );
2363 return S_OK;
2364 }
2365
2366 static HRESULT WINAPI mrp_GetProperty( IWineMsiRemotePackage *iface, BSTR property, BSTR *value, DWORD *size )
2367 {
2368 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2369 UINT r;
2370
2371 r = MsiGetPropertyW(This->package, (LPWSTR)property, (LPWSTR)value, size);
2372 if (r != ERROR_SUCCESS)
2373 return HRESULT_FROM_WIN32(r);
2374
2375 return S_OK;
2376 }
2377
2378 static HRESULT WINAPI mrp_SetProperty( IWineMsiRemotePackage *iface, BSTR property, BSTR value )
2379 {
2380 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2381 UINT r = MsiSetPropertyW(This->package, property, value);
2382 return HRESULT_FROM_WIN32(r);
2383 }
2384
2385 static HRESULT WINAPI mrp_ProcessMessage( IWineMsiRemotePackage *iface, INSTALLMESSAGE message, MSIHANDLE record )
2386 {
2387 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2388 UINT r = MsiProcessMessage(This->package, message, record);
2389 return HRESULT_FROM_WIN32(r);
2390 }
2391
2392 static HRESULT WINAPI mrp_DoAction( IWineMsiRemotePackage *iface, BSTR action )
2393 {
2394 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2395 UINT r = MsiDoActionW(This->package, action);
2396 return HRESULT_FROM_WIN32(r);
2397 }
2398
2399 static HRESULT WINAPI mrp_Sequence( IWineMsiRemotePackage *iface, BSTR table, int sequence )
2400 {
2401 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2402 UINT r = MsiSequenceW(This->package, table, sequence);
2403 return HRESULT_FROM_WIN32(r);
2404 }
2405
2406 static HRESULT WINAPI mrp_GetTargetPath( IWineMsiRemotePackage *iface, BSTR folder, BSTR *value, DWORD *size )
2407 {
2408 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2409 UINT r = MsiGetTargetPathW(This->package, (LPWSTR)folder, (LPWSTR)value, size);
2410 return HRESULT_FROM_WIN32(r);
2411 }
2412
2413 static HRESULT WINAPI mrp_SetTargetPath( IWineMsiRemotePackage *iface, BSTR folder, BSTR value)
2414 {
2415 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2416 UINT r = MsiSetTargetPathW(This->package, folder, value);
2417 return HRESULT_FROM_WIN32(r);
2418 }
2419
2420 static HRESULT WINAPI mrp_GetSourcePath( IWineMsiRemotePackage *iface, BSTR folder, BSTR *value, DWORD *size )
2421 {
2422 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2423 UINT r = MsiGetSourcePathW(This->package, (LPWSTR)folder, (LPWSTR)value, size);
2424 return HRESULT_FROM_WIN32(r);
2425 }
2426
2427 static HRESULT WINAPI mrp_GetMode( IWineMsiRemotePackage *iface, MSIRUNMODE mode, BOOL *ret )
2428 {
2429 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2430 *ret = MsiGetMode(This->package, mode);
2431 return S_OK;
2432 }
2433
2434 static HRESULT WINAPI mrp_SetMode( IWineMsiRemotePackage *iface, MSIRUNMODE mode, BOOL state )
2435 {
2436 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2437 UINT r = MsiSetMode(This->package, mode, state);
2438 return HRESULT_FROM_WIN32(r);
2439 }
2440
2441 static HRESULT WINAPI mrp_GetFeatureState( IWineMsiRemotePackage *iface, BSTR feature,
2442 INSTALLSTATE *installed, INSTALLSTATE *action )
2443 {
2444 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2445 UINT r = MsiGetFeatureStateW(This->package, feature, installed, action);
2446 return HRESULT_FROM_WIN32(r);
2447 }
2448
2449 static HRESULT WINAPI mrp_SetFeatureState( IWineMsiRemotePackage *iface, BSTR feature, INSTALLSTATE state )
2450 {
2451 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2452 UINT r = MsiSetFeatureStateW(This->package, feature, state);
2453 return HRESULT_FROM_WIN32(r);
2454 }
2455
2456 static HRESULT WINAPI mrp_GetComponentState( IWineMsiRemotePackage *iface, BSTR component,
2457 INSTALLSTATE *installed, INSTALLSTATE *action )
2458 {
2459 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2460 UINT r = MsiGetComponentStateW(This->package, component, installed, action);
2461 return HRESULT_FROM_WIN32(r);
2462 }
2463
2464 static HRESULT WINAPI mrp_SetComponentState( IWineMsiRemotePackage *iface, BSTR component, INSTALLSTATE state )
2465 {
2466 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2467 UINT r = MsiSetComponentStateW(This->package, component, state);
2468 return HRESULT_FROM_WIN32(r);
2469 }
2470
2471 static HRESULT WINAPI mrp_GetLanguage( IWineMsiRemotePackage *iface, LANGID *language )
2472 {
2473 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2474 *language = MsiGetLanguage(This->package);
2475 return S_OK;
2476 }
2477
2478 static HRESULT WINAPI mrp_SetInstallLevel( IWineMsiRemotePackage *iface, int level )
2479 {
2480 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2481 UINT r = MsiSetInstallLevel(This->package, level);
2482 return HRESULT_FROM_WIN32(r);
2483 }
2484
2485 static HRESULT WINAPI mrp_FormatRecord( IWineMsiRemotePackage *iface, MSIHANDLE record,
2486 BSTR *value)
2487 {
2488 DWORD size = 0;
2489 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2490 UINT r = MsiFormatRecordW(This->package, record, NULL, &size);
2491 if (r == ERROR_SUCCESS)
2492 {
2493 *value = SysAllocStringLen(NULL, size);
2494 if (!*value)
2495 return E_OUTOFMEMORY;
2496 size++;
2497 r = MsiFormatRecordW(This->package, record, *value, &size);
2498 }
2499 return HRESULT_FROM_WIN32(r);
2500 }
2501
2502 static HRESULT WINAPI mrp_EvaluateCondition( IWineMsiRemotePackage *iface, BSTR condition )
2503 {
2504 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2505 UINT r = MsiEvaluateConditionW(This->package, condition);
2506 return HRESULT_FROM_WIN32(r);
2507 }
2508
2509 static HRESULT WINAPI mrp_GetFeatureCost( IWineMsiRemotePackage *iface, BSTR feature,
2510 INT cost_tree, INSTALLSTATE state, INT *cost )
2511 {
2512 msi_remote_package_impl* This = impl_from_IWineMsiRemotePackage( iface );
2513 UINT r = MsiGetFeatureCostW(This->package, feature, cost_tree, state, cost);
2514 return HRESULT_FROM_WIN32(r);
2515 }
2516
2517 static const IWineMsiRemotePackageVtbl msi_remote_package_vtbl =
2518 {
2519 mrp_QueryInterface,
2520 mrp_AddRef,
2521 mrp_Release,
2522 mrp_SetMsiHandle,
2523 mrp_GetActiveDatabase,
2524 mrp_GetProperty,
2525 mrp_SetProperty,
2526 mrp_ProcessMessage,
2527 mrp_DoAction,
2528 mrp_Sequence,
2529 mrp_GetTargetPath,
2530 mrp_SetTargetPath,
2531 mrp_GetSourcePath,
2532 mrp_GetMode,
2533 mrp_SetMode,
2534 mrp_GetFeatureState,
2535 mrp_SetFeatureState,
2536 mrp_GetComponentState,
2537 mrp_SetComponentState,
2538 mrp_GetLanguage,
2539 mrp_SetInstallLevel,
2540 mrp_FormatRecord,
2541 mrp_EvaluateCondition,
2542 mrp_GetFeatureCost,
2543 };
2544
2545 HRESULT create_msi_remote_package( IUnknown *pOuter, LPVOID *ppObj )
2546 {
2547 msi_remote_package_impl* This;
2548
2549 This = msi_alloc( sizeof *This );
2550 if (!This)
2551 return E_OUTOFMEMORY;
2552
2553 This->IWineMsiRemotePackage_iface.lpVtbl = &msi_remote_package_vtbl;
2554 This->package = 0;
2555 This->refs = 1;
2556
2557 *ppObj = This;
2558
2559 return S_OK;
2560 }
2561
2562 UINT msi_package_add_info(MSIPACKAGE *package, DWORD context, DWORD options,
2563 LPCWSTR property, LPWSTR value)
2564 {
2565 MSISOURCELISTINFO *info;
2566
2567 info = msi_alloc(sizeof(MSISOURCELISTINFO));
2568 if (!info)
2569 return ERROR_OUTOFMEMORY;
2570
2571 info->context = context;
2572 info->options = options;
2573 info->property = property;
2574 info->value = strdupW(value);
2575 list_add_head(&package->sourcelist_info, &info->entry);
2576
2577 return ERROR_SUCCESS;
2578 }
2579
2580 UINT msi_package_add_media_disk(MSIPACKAGE *package, DWORD context, DWORD options,
2581 DWORD disk_id, LPWSTR volume_label, LPWSTR disk_prompt)
2582 {
2583 MSIMEDIADISK *disk;
2584
2585 disk = msi_alloc(sizeof(MSIMEDIADISK));
2586 if (!disk)
2587 return ERROR_OUTOFMEMORY;
2588
2589 disk->context = context;
2590 disk->options = options;
2591 disk->disk_id = disk_id;
2592 disk->volume_label = strdupW(volume_label);
2593 disk->disk_prompt = strdupW(disk_prompt);
2594 list_add_head(&package->sourcelist_media, &disk->entry);
2595
2596 return ERROR_SUCCESS;
2597 }
Windows API implementation