?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mf/session: Forward more events to the application.
[wine/zf.git] / dlls / msi / action.c
blobcc5d56fdc2bf74f2fb43cbe21796316e44d1f8ff
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
3 *
4 * Copyright 2004,2005 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 #include <stdarg.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winerror.h"
28 #include "winreg.h"
29 #include "winsvc.h"
30 #include "odbcinst.h"
31 #include "wine/debug.h"
32 #include "msidefs.h"
33 #include "winuser.h"
34 #include "shlobj.h"
35 #include "objbase.h"
36 #include "mscoree.h"
37 #include "shlwapi.h"
38 #include "imagehlp.h"
39 #include "winver.h"
40
41 #include "msipriv.h"
42 #include "resource.h"
43
44 #define REG_PROGRESS_VALUE 13200
45 #define COMPONENT_PROGRESS_VALUE 24000
46
47 WINE_DEFAULT_DEBUG_CHANNEL(msi);
48
49 static INT ui_actionstart(MSIPACKAGE *package, LPCWSTR action, LPCWSTR description, LPCWSTR template)
50 {
51 MSIRECORD *row, *textrow;
52 INT rc;
53
54 textrow = MSI_QueryGetRecord(package->db, L"SELECT * FROM `ActionText` WHERE `Action` = '%s'", action);
55 if (textrow)
56 {
57 description = MSI_RecordGetString(textrow, 2);
58 template = MSI_RecordGetString(textrow, 3);
59 }
60
61 row = MSI_CreateRecord(3);
62 if (!row) return -1;
63 MSI_RecordSetStringW(row, 1, action);
64 MSI_RecordSetStringW(row, 2, description);
65 MSI_RecordSetStringW(row, 3, template);
66 rc = MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONSTART, row);
67 if (textrow) msiobj_release(&textrow->hdr);
68 msiobj_release(&row->hdr);
69 return rc;
70 }
71
72 static void ui_actioninfo(MSIPACKAGE *package, LPCWSTR action, BOOL start,
73 INT rc)
74 {
75 MSIRECORD *row;
76 WCHAR *template;
77
78 template = msi_get_error_message(package->db, start ? MSIERR_INFO_ACTIONSTART : MSIERR_INFO_ACTIONENDED);
79
80 row = MSI_CreateRecord(2);
81 if (!row)
82 {
83 msi_free(template);
84 return;
85 }
86 MSI_RecordSetStringW(row, 0, template);
87 MSI_RecordSetStringW(row, 1, action);
88 MSI_RecordSetInteger(row, 2, start ? package->LastActionResult : rc);
89 MSI_ProcessMessage(package, INSTALLMESSAGE_INFO, row);
90 msiobj_release(&row->hdr);
91 msi_free(template);
92 if (!start) package->LastActionResult = rc;
93 }
94
95 enum parse_state
96 {
97 state_whitespace,
98 state_token,
99 state_quote
100 };
101
102 static int parse_prop( const WCHAR *str, WCHAR *value, int *quotes )
103 {
104 enum parse_state state = state_quote;
105 const WCHAR *p;
106 WCHAR *out = value;
107 BOOL ignore, in_quotes = FALSE;
108 int count = 0, len = 0;
109
110 for (p = str; *p; p++)
111 {
112 ignore = FALSE;
113 switch (state)
114 {
115 case state_whitespace:
116 switch (*p)
117 {
118 case ' ':
119 in_quotes = TRUE;
120 ignore = TRUE;
121 len++;
122 break;
123 case '"':
124 state = state_quote;
125 if (in_quotes && p[1] != '\"') count--;
126 else count++;
127 break;
128 default:
129 state = state_token;
130 in_quotes = TRUE;
131 len++;
132 break;
133 }
134 break;
135
136 case state_token:
137 switch (*p)
138 {
139 case '"':
140 state = state_quote;
141 if (in_quotes) count--;
142 else count++;
143 break;
144 case ' ':
145 state = state_whitespace;
146 if (!count) goto done;
147 in_quotes = TRUE;
148 len++;
149 break;
150 default:
151 if (count) in_quotes = TRUE;
152 len++;
153 break;
154 }
155 break;
156
157 case state_quote:
158 switch (*p)
159 {
160 case '"':
161 if (in_quotes && p[1] != '\"') count--;
162 else count++;
163 break;
164 case ' ':
165 state = state_whitespace;
166 if (!count || (count > 1 && !len)) goto done;
167 in_quotes = TRUE;
168 len++;
169 break;
170 default:
171 state = state_token;
172 if (count) in_quotes = TRUE;
173 len++;
174 break;
175 }
176 break;
177
178 default: break;
179 }
180 if (!ignore && value) *out++ = *p;
181 if (!count) in_quotes = FALSE;
182 }
183
184 done:
185 if (value)
186 {
187 if (!len) *value = 0;
188 else *out = 0;
189 }
190
191 if(quotes) *quotes = count;
192 return p - str;
193 }
194
195 static void remove_quotes( WCHAR *str )
196 {
197 WCHAR *p = str;
198 int len = lstrlenW( str );
199
200 while ((p = wcschr( p, '"' )))
201 {
202 memmove( p, p + 1, (len - (p - str)) * sizeof(WCHAR) );
203 p++;
204 }
205 }
206
207 UINT msi_parse_command_line( MSIPACKAGE *package, LPCWSTR szCommandLine,
208 BOOL preserve_case )
209 {
210 LPCWSTR ptr, ptr2;
211 int num_quotes;
212 DWORD len;
213 WCHAR *prop, *val;
214 UINT r;
215
216 if (!szCommandLine)
217 return ERROR_SUCCESS;
218
219 ptr = szCommandLine;
220 while (*ptr)
221 {
222 while (*ptr == ' ') ptr++;
223 if (!*ptr) break;
224
225 ptr2 = wcschr( ptr, '=' );
226 if (!ptr2) return ERROR_INVALID_COMMAND_LINE;
227
228 len = ptr2 - ptr;
229 if (!len) return ERROR_INVALID_COMMAND_LINE;
230
231 while (ptr[len - 1] == ' ') len--;
232
233 prop = msi_alloc( (len + 1) * sizeof(WCHAR) );
234 memcpy( prop, ptr, len * sizeof(WCHAR) );
235 prop[len] = 0;
236 if (!preserve_case) wcsupr( prop );
237
238 ptr2++;
239 while (*ptr2 == ' ') ptr2++;
240
241 num_quotes = 0;
242 val = msi_alloc( (lstrlenW( ptr2 ) + 1) * sizeof(WCHAR) );
243 len = parse_prop( ptr2, val, &num_quotes );
244 if (num_quotes % 2)
245 {
246 WARN("unbalanced quotes\n");
247 msi_free( val );
248 msi_free( prop );
249 return ERROR_INVALID_COMMAND_LINE;
250 }
251 remove_quotes( val );
252 TRACE("Found commandline property %s = %s\n", debugstr_w(prop), debugstr_w(val));
253
254 r = msi_set_property( package->db, prop, val, -1 );
255 if (r == ERROR_SUCCESS && !wcscmp( prop, L"SourceDir" ))
256 msi_reset_source_folders( package );
257
258 msi_free( val );
259 msi_free( prop );
260
261 ptr = ptr2 + len;
262 }
263
264 return ERROR_SUCCESS;
265 }
266
267 const WCHAR *msi_get_command_line_option(const WCHAR *cmd, const WCHAR *option, UINT *len)
268 {
269 DWORD opt_len = lstrlenW(option);
270
271 if (!cmd)
272 return NULL;
273
274 while (*cmd)
275 {
276 BOOL found = FALSE;
277
278 while (*cmd == ' ') cmd++;
279 if (!*cmd) break;
280
281 if(!wcsnicmp(cmd, option, opt_len))
282 found = TRUE;
283
284 cmd = wcschr( cmd, '=' );
285 if(!cmd) break;
286 cmd++;
287 while (*cmd == ' ') cmd++;
288 if (!*cmd) break;
289
290 *len = parse_prop( cmd, NULL, NULL);
291 if (found) return cmd;
292 cmd += *len;
293 }
294
295 return NULL;
296 }
297
298 WCHAR **msi_split_string( const WCHAR *str, WCHAR sep )
299 {
300 LPCWSTR pc;
301 LPWSTR p, *ret = NULL;
302 UINT count = 0;
303
304 if (!str)
305 return ret;
306
307 /* count the number of substrings */
308 for ( pc = str, count = 0; pc; count++ )
309 {
310 pc = wcschr( pc, sep );
311 if (pc)
312 pc++;
313 }
314
315 /* allocate space for an array of substring pointers and the substrings */
316 ret = msi_alloc( (count+1) * sizeof (LPWSTR) +
317 (lstrlenW(str)+1) * sizeof(WCHAR) );
318 if (!ret)
319 return ret;
320
321 /* copy the string and set the pointers */
322 p = (LPWSTR) &ret[count+1];
323 lstrcpyW( p, str );
324 for( count = 0; (ret[count] = p); count++ )
325 {
326 p = wcschr( p, sep );
327 if (p)
328 *p++ = 0;
329 }
330
331 return ret;
332 }
333
334 static BOOL ui_sequence_exists( MSIPACKAGE *package )
335 {
336 MSIQUERY *view;
337 DWORD count = 0;
338
339 if (!(MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `InstallUISequence` WHERE `Sequence` > 0", &view )))
340 {
341 MSI_IterateRecords( view, &count, NULL, package );
342 msiobj_release( &view->hdr );
343 }
344 return count != 0;
345 }
346
347 UINT msi_set_sourcedir_props(MSIPACKAGE *package, BOOL replace)
348 {
349 WCHAR *source, *check, *p, *db;
350 DWORD len;
351
352 if (!(db = msi_dup_property( package->db, L"OriginalDatabase" )))
353 return ERROR_OUTOFMEMORY;
354
355 if (!(p = wcsrchr( db, '\\' )) && !(p = wcsrchr( db, '/' )))
356 {
357 msi_free(db);
358 return ERROR_SUCCESS;
359 }
360 len = p - db + 2;
361 source = msi_alloc( len * sizeof(WCHAR) );
362 lstrcpynW( source, db, len );
363 msi_free( db );
364
365 check = msi_dup_property( package->db, L"SourceDir" );
366 if (!check || replace)
367 {
368 UINT r = msi_set_property( package->db, L"SourceDir", source, -1 );
369 if (r == ERROR_SUCCESS)
370 msi_reset_source_folders( package );
371 }
372 msi_free( check );
373
374 check = msi_dup_property( package->db, L"SOURCEDIR" );
375 if (!check || replace)
376 msi_set_property( package->db, L"SOURCEDIR", source, -1 );
377
378 msi_free( check );
379 msi_free( source );
380
381 return ERROR_SUCCESS;
382 }
383
384 static BOOL needs_ui_sequence(MSIPACKAGE *package)
385 {
386 return (package->ui_level & INSTALLUILEVEL_MASK) >= INSTALLUILEVEL_REDUCED;
387 }
388
389 UINT msi_set_context(MSIPACKAGE *package)
390 {
391 UINT r = msi_locate_product( package->ProductCode, &package->Context );
392 if (r != ERROR_SUCCESS)
393 {
394 int num = msi_get_property_int( package->db, L"ALLUSERS", 0 );
395 if (num == 1 || num == 2)
396 package->Context = MSIINSTALLCONTEXT_MACHINE;
397 else
398 package->Context = MSIINSTALLCONTEXT_USERUNMANAGED;
399 }
400 return ERROR_SUCCESS;
401 }
402
403 static UINT ITERATE_Actions(MSIRECORD *row, LPVOID param)
404 {
405 UINT rc;
406 LPCWSTR cond, action;
407 MSIPACKAGE *package = param;
408
409 action = MSI_RecordGetString(row,1);
410 if (!action)
411 {
412 ERR("Error is retrieving action name\n");
413 return ERROR_FUNCTION_FAILED;
414 }
415
416 /* check conditions */
417 cond = MSI_RecordGetString(row,2);
418
419 /* this is a hack to skip errors in the condition code */
420 if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
421 {
422 TRACE("Skipping action: %s (condition is false)\n", debugstr_w(action));
423 return ERROR_SUCCESS;
424 }
425
426 rc = ACTION_PerformAction(package, action);
427
428 msi_dialog_check_messages( NULL );
429
430 if (rc == ERROR_FUNCTION_NOT_CALLED)
431 rc = ERROR_SUCCESS;
432
433 if (rc != ERROR_SUCCESS)
434 ERR("Execution halted, action %s returned %i\n", debugstr_w(action), rc);
435
436 if (package->need_reboot_now)
437 {
438 TRACE("action %s asked for immediate reboot, suspending installation\n",
439 debugstr_w(action));
440 rc = ACTION_ForceReboot( package );
441 }
442 return rc;
443 }
444
445 UINT MSI_Sequence( MSIPACKAGE *package, LPCWSTR table )
446 {
447 MSIQUERY *view;
448 UINT r;
449
450 TRACE("%p %s\n", package, debugstr_w(table));
451
452 r = MSI_OpenQuery( package->db, &view, L"SELECT * FROM `%s` WHERE `Sequence` > 0 ORDER BY `Sequence`", table );
453 if (r == ERROR_SUCCESS)
454 {
455 r = MSI_IterateRecords( view, NULL, ITERATE_Actions, package );
456 msiobj_release(&view->hdr);
457 }
458 return r;
459 }
460
461 static UINT ACTION_ProcessExecSequence(MSIPACKAGE *package)
462 {
463 MSIQUERY *view;
464 UINT rc;
465
466 if (package->ExecuteSequenceRun)
467 {
468 TRACE("Execute Sequence already Run\n");
469 return ERROR_SUCCESS;
470 }
471
472 package->ExecuteSequenceRun = TRUE;
473
474 rc = MSI_OpenQuery(package->db, &view,
475 L"SELECT * FROM `InstallExecuteSequence` WHERE `Sequence` > 0 ORDER BY `Sequence`");
476 if (rc == ERROR_SUCCESS)
477 {
478 TRACE("Running the actions\n");
479
480 msi_set_property( package->db, L"SourceDir", NULL, -1 );
481 rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, package);
482 msiobj_release(&view->hdr);
483 }
484 return rc;
485 }
486
487 static UINT ACTION_ProcessUISequence(MSIPACKAGE *package)
488 {
489 MSIQUERY *view;
490 UINT rc;
491
492 rc = MSI_DatabaseOpenViewW(package->db,
493 L"SELECT * FROM `InstallUISequence` WHERE `Sequence` > 0 ORDER BY `Sequence`",
494 &view);
495 if (rc == ERROR_SUCCESS)
496 {
497 TRACE("Running the actions\n");
498 rc = MSI_IterateRecords(view, NULL, ITERATE_Actions, package);
499 msiobj_release(&view->hdr);
500 }
501 return rc;
502 }
503
504 /********************************************************
505 * ACTION helper functions and functions that perform the actions
506 *******************************************************/
507 static UINT ACTION_HandleCustomAction(MSIPACKAGE *package, LPCWSTR action)
508 {
509 UINT arc;
510 INT uirc;
511
512 uirc = ui_actionstart(package, action, NULL, NULL);
513 if (uirc == IDCANCEL)
514 return ERROR_INSTALL_USEREXIT;
515 ui_actioninfo(package, action, TRUE, 0);
516 arc = ACTION_CustomAction(package, action);
517 uirc = !arc;
518
519 if (arc == ERROR_FUNCTION_NOT_CALLED && needs_ui_sequence(package))
520 {
521 uirc = ACTION_ShowDialog(package, action);
522 switch (uirc)
523 {
524 case -1:
525 return ERROR_SUCCESS; /* stop immediately */
526 case 0: arc = ERROR_FUNCTION_NOT_CALLED; break;
527 case 1: arc = ERROR_SUCCESS; break;
528 case 2: arc = ERROR_INSTALL_USEREXIT; break;
529 case 3: arc = ERROR_INSTALL_FAILURE; break;
530 case 4: arc = ERROR_INSTALL_SUSPEND; break;
531 case 5: arc = ERROR_MORE_DATA; break;
532 case 6: arc = ERROR_INVALID_HANDLE_STATE; break;
533 case 7: arc = ERROR_INVALID_DATA; break;
534 case 8: arc = ERROR_INSTALL_ALREADY_RUNNING; break;
535 case 9: arc = ERROR_INSTALL_PACKAGE_REJECTED; break;
536 default: arc = ERROR_FUNCTION_FAILED; break;
537 }
538 }
539
540 ui_actioninfo(package, action, FALSE, uirc);
541
542 return arc;
543 }
544
545 MSICOMPONENT *msi_get_loaded_component( MSIPACKAGE *package, const WCHAR *Component )
546 {
547 MSICOMPONENT *comp;
548
549 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
550 {
551 if (!wcscmp( Component, comp->Component )) return comp;
552 }
553 return NULL;
554 }
555
556 MSIFEATURE *msi_get_loaded_feature(MSIPACKAGE* package, const WCHAR *Feature )
557 {
558 MSIFEATURE *feature;
559
560 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
561 {
562 if (!wcscmp( Feature, feature->Feature )) return feature;
563 }
564 return NULL;
565 }
566
567 MSIFILE *msi_get_loaded_file( MSIPACKAGE *package, const WCHAR *key )
568 {
569 MSIFILE *file;
570
571 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
572 {
573 if (!wcscmp( key, file->File )) return file;
574 }
575 return NULL;
576 }
577
578 MSIFOLDER *msi_get_loaded_folder( MSIPACKAGE *package, const WCHAR *dir )
579 {
580 MSIFOLDER *folder;
581
582 LIST_FOR_EACH_ENTRY( folder, &package->folders, MSIFOLDER, entry )
583 {
584 if (!wcscmp( dir, folder->Directory )) return folder;
585 }
586 return NULL;
587 }
588
589 void msi_ui_progress( MSIPACKAGE *package, int a, int b, int c, int d )
590 {
591 MSIRECORD *row;
592
593 row = MSI_CreateRecord( 4 );
594 MSI_RecordSetInteger( row, 1, a );
595 MSI_RecordSetInteger( row, 2, b );
596 MSI_RecordSetInteger( row, 3, c );
597 MSI_RecordSetInteger( row, 4, d );
598 MSI_ProcessMessage( package, INSTALLMESSAGE_PROGRESS, row );
599 msiobj_release( &row->hdr );
600
601 msi_dialog_check_messages( NULL );
602 }
603
604 INSTALLSTATE msi_get_component_action( MSIPACKAGE *package, MSICOMPONENT *comp )
605 {
606 if (!comp->Enabled)
607 {
608 TRACE("component is disabled: %s\n", debugstr_w(comp->Component));
609 return INSTALLSTATE_UNKNOWN;
610 }
611 if (package->need_rollback) return comp->Installed;
612 if (comp->num_clients > 0 && comp->ActionRequest == INSTALLSTATE_ABSENT)
613 {
614 TRACE("%s has %u clients left\n", debugstr_w(comp->Component), comp->num_clients);
615 return INSTALLSTATE_UNKNOWN;
616 }
617 return comp->ActionRequest;
618 }
619
620 INSTALLSTATE msi_get_feature_action( MSIPACKAGE *package, MSIFEATURE *feature )
621 {
622 if (package->need_rollback) return feature->Installed;
623 return feature->ActionRequest;
624 }
625
626 static UINT ITERATE_CreateFolders(MSIRECORD *row, LPVOID param)
627 {
628 MSIPACKAGE *package = param;
629 LPCWSTR dir, component, full_path;
630 MSIRECORD *uirow;
631 MSIFOLDER *folder;
632 MSICOMPONENT *comp;
633
634 component = MSI_RecordGetString(row, 2);
635 if (!component)
636 return ERROR_SUCCESS;
637
638 comp = msi_get_loaded_component(package, component);
639 if (!comp)
640 return ERROR_SUCCESS;
641
642 comp->Action = msi_get_component_action( package, comp );
643 if (comp->Action != INSTALLSTATE_LOCAL)
644 {
645 TRACE("component not scheduled for installation: %s\n", debugstr_w(component));
646 return ERROR_SUCCESS;
647 }
648
649 dir = MSI_RecordGetString(row,1);
650 if (!dir)
651 {
652 ERR("Unable to get folder id\n");
653 return ERROR_SUCCESS;
654 }
655
656 uirow = MSI_CreateRecord(1);
657 MSI_RecordSetStringW(uirow, 1, dir);
658 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
659 msiobj_release(&uirow->hdr);
660
661 full_path = msi_get_target_folder( package, dir );
662 if (!full_path)
663 {
664 ERR("Unable to retrieve folder %s\n", debugstr_w(dir));
665 return ERROR_SUCCESS;
666 }
667 TRACE("folder is %s\n", debugstr_w(full_path));
668
669 folder = msi_get_loaded_folder( package, dir );
670 if (folder->State == FOLDER_STATE_UNINITIALIZED) msi_create_full_path( package, full_path );
671 folder->State = FOLDER_STATE_CREATED;
672
673 return ERROR_SUCCESS;
674 }
675
676 static UINT ACTION_CreateFolders(MSIPACKAGE *package)
677 {
678 MSIQUERY *view;
679 UINT rc;
680
681 if (package->script == SCRIPT_NONE)
682 return msi_schedule_action(package, SCRIPT_INSTALL, L"CreateFolders");
683
684 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `CreateFolder`", &view );
685 if (rc != ERROR_SUCCESS)
686 return ERROR_SUCCESS;
687
688 rc = MSI_IterateRecords(view, NULL, ITERATE_CreateFolders, package);
689 msiobj_release(&view->hdr);
690 return rc;
691 }
692
693 static void remove_persistent_folder( MSIFOLDER *folder )
694 {
695 FolderList *fl;
696
697 LIST_FOR_EACH_ENTRY( fl, &folder->children, FolderList, entry )
698 {
699 remove_persistent_folder( fl->folder );
700 }
701 if (folder->persistent && folder->State != FOLDER_STATE_REMOVED)
702 {
703 if (RemoveDirectoryW( folder->ResolvedTarget )) folder->State = FOLDER_STATE_REMOVED;
704 }
705 }
706
707 static UINT ITERATE_RemoveFolders( MSIRECORD *row, LPVOID param )
708 {
709 MSIPACKAGE *package = param;
710 LPCWSTR dir, component, full_path;
711 MSIRECORD *uirow;
712 MSIFOLDER *folder;
713 MSICOMPONENT *comp;
714
715 component = MSI_RecordGetString(row, 2);
716 if (!component)
717 return ERROR_SUCCESS;
718
719 comp = msi_get_loaded_component(package, component);
720 if (!comp)
721 return ERROR_SUCCESS;
722
723 comp->Action = msi_get_component_action( package, comp );
724 if (comp->Action != INSTALLSTATE_ABSENT)
725 {
726 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
727 return ERROR_SUCCESS;
728 }
729
730 dir = MSI_RecordGetString( row, 1 );
731 if (!dir)
732 {
733 ERR("Unable to get folder id\n");
734 return ERROR_SUCCESS;
735 }
736
737 full_path = msi_get_target_folder( package, dir );
738 if (!full_path)
739 {
740 ERR("Unable to resolve folder %s\n", debugstr_w(dir));
741 return ERROR_SUCCESS;
742 }
743 TRACE("folder is %s\n", debugstr_w(full_path));
744
745 uirow = MSI_CreateRecord( 1 );
746 MSI_RecordSetStringW( uirow, 1, dir );
747 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
748 msiobj_release( &uirow->hdr );
749
750 folder = msi_get_loaded_folder( package, dir );
751 remove_persistent_folder( folder );
752 return ERROR_SUCCESS;
753 }
754
755 static UINT ACTION_RemoveFolders( MSIPACKAGE *package )
756 {
757 MSIQUERY *view;
758 UINT rc;
759
760 if (package->script == SCRIPT_NONE)
761 return msi_schedule_action(package, SCRIPT_INSTALL, L"RemoveFolders");
762
763 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `CreateFolder`", &view );
764 if (rc != ERROR_SUCCESS)
765 return ERROR_SUCCESS;
766
767 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveFolders, package );
768 msiobj_release( &view->hdr );
769 return rc;
770 }
771
772 static UINT load_component( MSIRECORD *row, LPVOID param )
773 {
774 MSIPACKAGE *package = param;
775 MSICOMPONENT *comp;
776
777 comp = msi_alloc_zero( sizeof(MSICOMPONENT) );
778 if (!comp)
779 return ERROR_FUNCTION_FAILED;
780
781 list_add_tail( &package->components, &comp->entry );
782
783 /* fill in the data */
784 comp->Component = msi_dup_record_field( row, 1 );
785
786 TRACE("Loading Component %s\n", debugstr_w(comp->Component));
787
788 comp->ComponentId = msi_dup_record_field( row, 2 );
789 comp->Directory = msi_dup_record_field( row, 3 );
790 comp->Attributes = MSI_RecordGetInteger(row,4);
791 comp->Condition = msi_dup_record_field( row, 5 );
792 comp->KeyPath = msi_dup_record_field( row, 6 );
793
794 comp->Installed = INSTALLSTATE_UNKNOWN;
795 comp->Action = INSTALLSTATE_UNKNOWN;
796 comp->ActionRequest = INSTALLSTATE_UNKNOWN;
797
798 comp->assembly = msi_load_assembly( package, comp );
799 return ERROR_SUCCESS;
800 }
801
802 UINT msi_load_all_components( MSIPACKAGE *package )
803 {
804 MSIQUERY *view;
805 UINT r;
806
807 if (!list_empty(&package->components))
808 return ERROR_SUCCESS;
809
810 r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Component`", &view );
811 if (r != ERROR_SUCCESS)
812 return r;
813
814 r = MSI_IterateRecords(view, NULL, load_component, package);
815 msiobj_release(&view->hdr);
816 return r;
817 }
818
819 typedef struct {
820 MSIPACKAGE *package;
821 MSIFEATURE *feature;
822 } _ilfs;
823
824 static UINT add_feature_component( MSIFEATURE *feature, MSICOMPONENT *comp )
825 {
826 ComponentList *cl;
827
828 cl = msi_alloc( sizeof (*cl) );
829 if ( !cl )
830 return ERROR_NOT_ENOUGH_MEMORY;
831 cl->component = comp;
832 list_add_tail( &feature->Components, &cl->entry );
833
834 return ERROR_SUCCESS;
835 }
836
837 static UINT add_feature_child( MSIFEATURE *parent, MSIFEATURE *child )
838 {
839 FeatureList *fl;
840
841 fl = msi_alloc( sizeof(*fl) );
842 if ( !fl )
843 return ERROR_NOT_ENOUGH_MEMORY;
844 fl->feature = child;
845 list_add_tail( &parent->Children, &fl->entry );
846
847 return ERROR_SUCCESS;
848 }
849
850 static UINT iterate_load_featurecomponents(MSIRECORD *row, LPVOID param)
851 {
852 _ilfs* ilfs = param;
853 LPCWSTR component;
854 MSICOMPONENT *comp;
855
856 component = MSI_RecordGetString(row,1);
857
858 /* check to see if the component is already loaded */
859 comp = msi_get_loaded_component( ilfs->package, component );
860 if (!comp)
861 {
862 WARN("ignoring unknown component %s\n", debugstr_w(component));
863 return ERROR_SUCCESS;
864 }
865 add_feature_component( ilfs->feature, comp );
866 comp->Enabled = TRUE;
867
868 return ERROR_SUCCESS;
869 }
870
871 static UINT load_feature(MSIRECORD *row, LPVOID param)
872 {
873 MSIPACKAGE *package = param;
874 MSIFEATURE *feature;
875 MSIQUERY *view;
876 _ilfs ilfs;
877 UINT rc;
878
879 /* fill in the data */
880
881 feature = msi_alloc_zero( sizeof (MSIFEATURE) );
882 if (!feature)
883 return ERROR_NOT_ENOUGH_MEMORY;
884
885 list_init( &feature->Children );
886 list_init( &feature->Components );
887
888 feature->Feature = msi_dup_record_field( row, 1 );
889
890 TRACE("Loading feature %s\n",debugstr_w(feature->Feature));
891
892 feature->Feature_Parent = msi_dup_record_field( row, 2 );
893 feature->Title = msi_dup_record_field( row, 3 );
894 feature->Description = msi_dup_record_field( row, 4 );
895
896 if (!MSI_RecordIsNull(row,5))
897 feature->Display = MSI_RecordGetInteger(row,5);
898
899 feature->Level= MSI_RecordGetInteger(row,6);
900 feature->Directory = msi_dup_record_field( row, 7 );
901 feature->Attributes = MSI_RecordGetInteger(row,8);
902
903 feature->Installed = INSTALLSTATE_UNKNOWN;
904 feature->Action = INSTALLSTATE_UNKNOWN;
905 feature->ActionRequest = INSTALLSTATE_UNKNOWN;
906
907 list_add_tail( &package->features, &feature->entry );
908
909 /* load feature components */
910
911 rc = MSI_OpenQuery( package->db, &view, L"SELECT `Component_` FROM `FeatureComponents` WHERE `Feature_` = '%s'",
912 feature->Feature );
913 if (rc != ERROR_SUCCESS)
914 return ERROR_SUCCESS;
915
916 ilfs.package = package;
917 ilfs.feature = feature;
918
919 rc = MSI_IterateRecords(view, NULL, iterate_load_featurecomponents , &ilfs);
920 msiobj_release(&view->hdr);
921 return rc;
922 }
923
924 static UINT find_feature_children(MSIRECORD * row, LPVOID param)
925 {
926 MSIPACKAGE *package = param;
927 MSIFEATURE *parent, *child;
928
929 child = msi_get_loaded_feature( package, MSI_RecordGetString( row, 1 ) );
930 if (!child)
931 return ERROR_FUNCTION_FAILED;
932
933 if (!child->Feature_Parent)
934 return ERROR_SUCCESS;
935
936 parent = msi_get_loaded_feature( package, child->Feature_Parent );
937 if (!parent)
938 return ERROR_FUNCTION_FAILED;
939
940 add_feature_child( parent, child );
941 return ERROR_SUCCESS;
942 }
943
944 UINT msi_load_all_features( MSIPACKAGE *package )
945 {
946 MSIQUERY *view;
947 UINT r;
948
949 if (!list_empty(&package->features))
950 return ERROR_SUCCESS;
951
952 r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Feature` ORDER BY `Display`", &view );
953 if (r != ERROR_SUCCESS)
954 return r;
955
956 r = MSI_IterateRecords( view, NULL, load_feature, package );
957 if (r != ERROR_SUCCESS)
958 {
959 msiobj_release( &view->hdr );
960 return r;
961 }
962 r = MSI_IterateRecords( view, NULL, find_feature_children, package );
963 msiobj_release( &view->hdr );
964 return r;
965 }
966
967 static LPWSTR folder_split_path(LPWSTR p, WCHAR ch)
968 {
969 if (!p)
970 return p;
971 p = wcschr(p, ch);
972 if (!p)
973 return p;
974 *p = 0;
975 return p+1;
976 }
977
978 static UINT load_file_hash(MSIPACKAGE *package, MSIFILE *file)
979 {
980 MSIQUERY *view = NULL;
981 MSIRECORD *row = NULL;
982 UINT r;
983
984 TRACE("%s\n", debugstr_w(file->File));
985
986 r = MSI_OpenQuery(package->db, &view, L"SELECT * FROM `MsiFileHash` WHERE `File_` = '%s'", file->File);
987 if (r != ERROR_SUCCESS)
988 goto done;
989
990 r = MSI_ViewExecute(view, NULL);
991 if (r != ERROR_SUCCESS)
992 goto done;
993
994 r = MSI_ViewFetch(view, &row);
995 if (r != ERROR_SUCCESS)
996 goto done;
997
998 file->hash.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
999 file->hash.dwData[0] = MSI_RecordGetInteger(row, 3);
1000 file->hash.dwData[1] = MSI_RecordGetInteger(row, 4);
1001 file->hash.dwData[2] = MSI_RecordGetInteger(row, 5);
1002 file->hash.dwData[3] = MSI_RecordGetInteger(row, 6);
1003
1004 done:
1005 if (view) msiobj_release(&view->hdr);
1006 if (row) msiobj_release(&row->hdr);
1007 return r;
1008 }
1009
1010 static UINT load_file_disk_id( MSIPACKAGE *package, MSIFILE *file )
1011 {
1012 MSIRECORD *row = MSI_QueryGetRecord( package->db, L"SELECT `DiskId` FROM `Media` WHERE `LastSequence` >= %d",
1013 file->Sequence );
1014 if (!row)
1015 {
1016 WARN("query failed\n");
1017 return ERROR_FUNCTION_FAILED;
1018 }
1019
1020 file->disk_id = MSI_RecordGetInteger( row, 1 );
1021 msiobj_release( &row->hdr );
1022 return ERROR_SUCCESS;
1023 }
1024
1025 static UINT load_file(MSIRECORD *row, LPVOID param)
1026 {
1027 MSIPACKAGE* package = param;
1028 LPCWSTR component;
1029 MSIFILE *file;
1030
1031 /* fill in the data */
1032
1033 file = msi_alloc_zero( sizeof (MSIFILE) );
1034 if (!file)
1035 return ERROR_NOT_ENOUGH_MEMORY;
1036
1037 file->File = msi_dup_record_field( row, 1 );
1038
1039 component = MSI_RecordGetString( row, 2 );
1040 file->Component = msi_get_loaded_component( package, component );
1041
1042 if (!file->Component)
1043 {
1044 WARN("Component not found: %s\n", debugstr_w(component));
1045 msi_free(file->File);
1046 msi_free(file);
1047 return ERROR_SUCCESS;
1048 }
1049
1050 file->FileName = msi_dup_record_field( row, 3 );
1051 msi_reduce_to_long_filename( file->FileName );
1052
1053 file->ShortName = msi_dup_record_field( row, 3 );
1054 file->LongName = strdupW( folder_split_path(file->ShortName, '|'));
1055
1056 file->FileSize = MSI_RecordGetInteger( row, 4 );
1057 file->Version = msi_dup_record_field( row, 5 );
1058 file->Language = msi_dup_record_field( row, 6 );
1059 file->Attributes = MSI_RecordGetInteger( row, 7 );
1060 file->Sequence = MSI_RecordGetInteger( row, 8 );
1061
1062 file->state = msifs_invalid;
1063
1064 /* if the compressed bits are not set in the file attributes,
1065 * then read the information from the package word count property
1066 */
1067 if (package->WordCount & msidbSumInfoSourceTypeAdminImage)
1068 {
1069 file->IsCompressed = package->WordCount & msidbSumInfoSourceTypeCompressed;
1070 }
1071 else if (file->Attributes & (msidbFileAttributesCompressed | msidbFileAttributesPatchAdded))
1072 {
1073 file->IsCompressed = TRUE;
1074 }
1075 else if (file->Attributes & msidbFileAttributesNoncompressed)
1076 {
1077 file->IsCompressed = FALSE;
1078 }
1079 else file->IsCompressed = package->WordCount & msidbSumInfoSourceTypeCompressed;
1080
1081 load_file_hash(package, file);
1082 load_file_disk_id(package, file);
1083
1084 TRACE("File loaded (file %s sequence %u)\n", debugstr_w(file->File), file->Sequence);
1085
1086 list_add_tail( &package->files, &file->entry );
1087 return ERROR_SUCCESS;
1088 }
1089
1090 static UINT load_all_files(MSIPACKAGE *package)
1091 {
1092 MSIQUERY *view;
1093 UINT rc;
1094
1095 if (!list_empty(&package->files))
1096 return ERROR_SUCCESS;
1097
1098 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `File` ORDER BY `Sequence`", &view);
1099 if (rc != ERROR_SUCCESS)
1100 return ERROR_SUCCESS;
1101
1102 rc = MSI_IterateRecords(view, NULL, load_file, package);
1103 msiobj_release(&view->hdr);
1104 return rc;
1105 }
1106
1107 static UINT load_media( MSIRECORD *row, LPVOID param )
1108 {
1109 MSIPACKAGE *package = param;
1110 UINT disk_id = MSI_RecordGetInteger( row, 1 );
1111 const WCHAR *cabinet = MSI_RecordGetString( row, 4 );
1112
1113 /* FIXME: load external cabinets and directory sources too */
1114 if (!cabinet || cabinet[0] != '#' || disk_id >= MSI_INITIAL_MEDIA_TRANSFORM_DISKID)
1115 return ERROR_SUCCESS;
1116
1117 return msi_add_cabinet_stream( package, disk_id, package->db->storage, cabinet );
1118 }
1119
1120 static UINT load_all_media( MSIPACKAGE *package )
1121 {
1122 MSIQUERY *view;
1123 UINT r;
1124
1125 r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Media` ORDER BY `DiskId`", &view );
1126 if (r != ERROR_SUCCESS)
1127 return ERROR_SUCCESS;
1128
1129 r = MSI_IterateRecords( view, NULL, load_media, package );
1130 msiobj_release( &view->hdr );
1131 return r;
1132 }
1133
1134 static UINT load_patch_disk_id( MSIPACKAGE *package, MSIFILEPATCH *patch )
1135 {
1136 MSIRECORD *rec = MSI_QueryGetRecord( package->db, L"SELECT `DiskId` FROM `Media` WHERE `LastSequence` >= %u",
1137 patch->Sequence );
1138 if (!rec)
1139 {
1140 WARN("query failed\n");
1141 return ERROR_FUNCTION_FAILED;
1142 }
1143
1144 patch->disk_id = MSI_RecordGetInteger( rec, 1 );
1145 msiobj_release( &rec->hdr );
1146 return ERROR_SUCCESS;
1147 }
1148
1149 static UINT load_patch(MSIRECORD *row, LPVOID param)
1150 {
1151 MSIPACKAGE *package = param;
1152 MSIFILEPATCH *patch;
1153 const WCHAR *file_key;
1154
1155 patch = msi_alloc_zero( sizeof (MSIFILEPATCH) );
1156 if (!patch)
1157 return ERROR_NOT_ENOUGH_MEMORY;
1158
1159 file_key = MSI_RecordGetString( row, 1 );
1160 patch->File = msi_get_loaded_file( package, file_key );
1161 if (!patch->File)
1162 {
1163 ERR("Failed to find target for patch in File table\n");
1164 msi_free(patch);
1165 return ERROR_FUNCTION_FAILED;
1166 }
1167
1168 patch->Sequence = MSI_RecordGetInteger( row, 2 );
1169 patch->PatchSize = MSI_RecordGetInteger( row, 3 );
1170 patch->Attributes = MSI_RecordGetInteger( row, 4 );
1171
1172 /* FIXME:
1173 * Header field - for patch validation.
1174 * _StreamRef - External key into MsiPatchHeaders (instead of the header field)
1175 */
1176
1177 load_patch_disk_id( package, patch );
1178
1179 TRACE("Patch loaded (file %s sequence %u)\n", debugstr_w(patch->File->File), patch->Sequence);
1180
1181 list_add_tail( &package->filepatches, &patch->entry );
1182
1183 return ERROR_SUCCESS;
1184 }
1185
1186 static UINT load_all_patches(MSIPACKAGE *package)
1187 {
1188 MSIQUERY *view;
1189 UINT rc;
1190
1191 if (!list_empty(&package->filepatches))
1192 return ERROR_SUCCESS;
1193
1194 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `Patch` ORDER BY `Sequence`", &view);
1195 if (rc != ERROR_SUCCESS)
1196 return ERROR_SUCCESS;
1197
1198 rc = MSI_IterateRecords(view, NULL, load_patch, package);
1199 msiobj_release(&view->hdr);
1200 return rc;
1201 }
1202
1203 static UINT iterate_patched_component( MSIRECORD *row, LPVOID param )
1204 {
1205 MSIPACKAGE *package = param;
1206 const WCHAR *name;
1207 MSICOMPONENT *c;
1208
1209 name = MSI_RecordGetString( row, 1 );
1210 TRACE( "found patched component: %s\n", wine_dbgstr_w(name) );
1211 c = msi_get_loaded_component( package, name );
1212 if (!c)
1213 return ERROR_SUCCESS;
1214
1215 c->updated = 1;
1216 if (!wcscmp( MSI_RecordGetString( row, 2 ), L"INSERT" ))
1217 c->added = 1;
1218 return ERROR_SUCCESS;
1219 }
1220
1221 static void mark_patched_components( MSIPACKAGE *package )
1222 {
1223 static const WCHAR select[] = L"SELECT `Row`, `Column` FROM `_TransformView` WHERE `Table`='Component'";
1224 MSIQUERY *q;
1225 UINT r;
1226
1227 r = MSI_OpenQuery( package->db, &q, select );
1228 if (r != ERROR_SUCCESS)
1229 return;
1230
1231 MSI_IterateRecords( q, NULL, iterate_patched_component, package );
1232 msiobj_release( &q->hdr );
1233
1234 while (1)
1235 {
1236 r = MSI_OpenQuery( package->db, &q, L"ALTER TABLE `_TransformView` FREE" );
1237 if (r != ERROR_SUCCESS)
1238 return;
1239 r = MSI_ViewExecute( q, NULL );
1240 msiobj_release( &q->hdr );
1241 if (r != ERROR_SUCCESS)
1242 return;
1243 }
1244 }
1245
1246 static UINT load_folder_persistence( MSIPACKAGE *package, MSIFOLDER *folder )
1247 {
1248 MSIQUERY *view;
1249
1250 folder->persistent = FALSE;
1251 if (!MSI_OpenQuery( package->db, &view, L"SELECT * FROM `CreateFolder` WHERE `Directory_` = '%s'",
1252 folder->Directory ))
1253 {
1254 if (!MSI_ViewExecute( view, NULL ))
1255 {
1256 MSIRECORD *rec;
1257 if (!MSI_ViewFetch( view, &rec ))
1258 {
1259 TRACE("directory %s is persistent\n", debugstr_w(folder->Directory));
1260 folder->persistent = TRUE;
1261 msiobj_release( &rec->hdr );
1262 }
1263 }
1264 msiobj_release( &view->hdr );
1265 }
1266 return ERROR_SUCCESS;
1267 }
1268
1269 static UINT load_folder( MSIRECORD *row, LPVOID param )
1270 {
1271 MSIPACKAGE *package = param;
1272 static WCHAR szEmpty[] = L"";
1273 LPWSTR p, tgt_short, tgt_long, src_short, src_long;
1274 MSIFOLDER *folder;
1275
1276 if (!(folder = msi_alloc_zero( sizeof(*folder) ))) return ERROR_NOT_ENOUGH_MEMORY;
1277 list_init( &folder->children );
1278 folder->Directory = msi_dup_record_field( row, 1 );
1279 folder->Parent = msi_dup_record_field( row, 2 );
1280 p = msi_dup_record_field(row, 3);
1281
1282 TRACE("%s\n", debugstr_w(folder->Directory));
1283
1284 /* split src and target dir */
1285 tgt_short = p;
1286 src_short = folder_split_path( p, ':' );
1287
1288 /* split the long and short paths */
1289 tgt_long = folder_split_path( tgt_short, '|' );
1290 src_long = folder_split_path( src_short, '|' );
1291
1292 /* check for no-op dirs */
1293 if (tgt_short && !wcscmp( L".", tgt_short ))
1294 tgt_short = szEmpty;
1295 if (src_short && !wcscmp( L".", src_short ))
1296 src_short = szEmpty;
1297
1298 if (!tgt_long)
1299 tgt_long = tgt_short;
1300
1301 if (!src_short) {
1302 src_short = tgt_short;
1303 src_long = tgt_long;
1304 }
1305
1306 if (!src_long)
1307 src_long = src_short;
1308
1309 /* FIXME: use the target short path too */
1310 folder->TargetDefault = strdupW(tgt_long);
1311 folder->SourceShortPath = strdupW(src_short);
1312 folder->SourceLongPath = strdupW(src_long);
1313 msi_free(p);
1314
1315 TRACE("TargetDefault = %s\n",debugstr_w( folder->TargetDefault ));
1316 TRACE("SourceLong = %s\n", debugstr_w( folder->SourceLongPath ));
1317 TRACE("SourceShort = %s\n", debugstr_w( folder->SourceShortPath ));
1318
1319 load_folder_persistence( package, folder );
1320
1321 list_add_tail( &package->folders, &folder->entry );
1322 return ERROR_SUCCESS;
1323 }
1324
1325 static UINT add_folder_child( MSIFOLDER *parent, MSIFOLDER *child )
1326 {
1327 FolderList *fl;
1328
1329 if (!(fl = msi_alloc( sizeof(*fl) ))) return ERROR_NOT_ENOUGH_MEMORY;
1330 fl->folder = child;
1331 list_add_tail( &parent->children, &fl->entry );
1332 return ERROR_SUCCESS;
1333 }
1334
1335 static UINT find_folder_children( MSIRECORD *row, LPVOID param )
1336 {
1337 MSIPACKAGE *package = param;
1338 MSIFOLDER *parent, *child;
1339
1340 if (!(child = msi_get_loaded_folder( package, MSI_RecordGetString( row, 1 ) )))
1341 return ERROR_FUNCTION_FAILED;
1342
1343 if (!child->Parent) return ERROR_SUCCESS;
1344
1345 if (!(parent = msi_get_loaded_folder( package, child->Parent )))
1346 return ERROR_FUNCTION_FAILED;
1347
1348 return add_folder_child( parent, child );
1349 }
1350
1351 static UINT load_all_folders( MSIPACKAGE *package )
1352 {
1353 MSIQUERY *view;
1354 UINT r;
1355
1356 if (!list_empty(&package->folders))
1357 return ERROR_SUCCESS;
1358
1359 r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Directory`", &view );
1360 if (r != ERROR_SUCCESS)
1361 return r;
1362
1363 r = MSI_IterateRecords( view, NULL, load_folder, package );
1364 if (r != ERROR_SUCCESS)
1365 {
1366 msiobj_release( &view->hdr );
1367 return r;
1368 }
1369 r = MSI_IterateRecords( view, NULL, find_folder_children, package );
1370 msiobj_release( &view->hdr );
1371 return r;
1372 }
1373
1374 static UINT ACTION_CostInitialize(MSIPACKAGE *package)
1375 {
1376 msi_set_property( package->db, L"CostingComplete", L"0", -1 );
1377 msi_set_property( package->db, L"ROOTDRIVE", L"C:\\", -1 );
1378
1379 load_all_folders( package );
1380 msi_load_all_components( package );
1381 msi_load_all_features( package );
1382 load_all_files( package );
1383 load_all_patches( package );
1384 mark_patched_components( package );
1385 load_all_media( package );
1386
1387 return ERROR_SUCCESS;
1388 }
1389
1390 static UINT execute_script( MSIPACKAGE *package, UINT script )
1391 {
1392 UINT i, rc = ERROR_SUCCESS;
1393
1394 TRACE("executing script %u\n", script);
1395
1396 package->script = script;
1397
1398 if (script == SCRIPT_ROLLBACK)
1399 {
1400 for (i = package->script_actions_count[script]; i > 0; i--)
1401 {
1402 rc = ACTION_PerformAction(package, package->script_actions[script][i-1]);
1403 if (rc != ERROR_SUCCESS)
1404 {
1405 ERR("Execution of script %i halted; action %s returned %u\n",
1406 script, debugstr_w(package->script_actions[script][i-1]), rc);
1407 break;
1408 }
1409 }
1410 }
1411 else
1412 {
1413 for (i = 0; i < package->script_actions_count[script]; i++)
1414 {
1415 rc = ACTION_PerformAction(package, package->script_actions[script][i]);
1416 if (rc != ERROR_SUCCESS)
1417 {
1418 ERR("Execution of script %i halted; action %s returned %u\n",
1419 script, debugstr_w(package->script_actions[script][i]), rc);
1420 break;
1421 }
1422 }
1423 }
1424
1425 package->script = SCRIPT_NONE;
1426
1427 msi_free_action_script(package, script);
1428 return rc;
1429 }
1430
1431 static UINT ACTION_FileCost(MSIPACKAGE *package)
1432 {
1433 return ERROR_SUCCESS;
1434 }
1435
1436 static void get_client_counts( MSIPACKAGE *package )
1437 {
1438 MSICOMPONENT *comp;
1439 HKEY hkey;
1440
1441 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
1442 {
1443 if (!comp->ComponentId) continue;
1444
1445 if (MSIREG_OpenUserDataComponentKey( comp->ComponentId, L"S-1-5-18", &hkey, FALSE ) &&
1446 MSIREG_OpenUserDataComponentKey( comp->ComponentId, NULL, &hkey, FALSE ))
1447 {
1448 comp->num_clients = 0;
1449 continue;
1450 }
1451 RegQueryInfoKeyW( hkey, NULL, NULL, NULL, NULL, NULL, NULL, (DWORD *)&comp->num_clients,
1452 NULL, NULL, NULL, NULL );
1453 RegCloseKey( hkey );
1454 }
1455 }
1456
1457 static void ACTION_GetComponentInstallStates(MSIPACKAGE *package)
1458 {
1459 MSICOMPONENT *comp;
1460 UINT r;
1461
1462 LIST_FOR_EACH_ENTRY(comp, &package->components, MSICOMPONENT, entry)
1463 {
1464 if (!comp->ComponentId) continue;
1465
1466 r = MsiQueryComponentStateW( package->ProductCode, NULL,
1467 MSIINSTALLCONTEXT_USERMANAGED, comp->ComponentId,
1468 &comp->Installed );
1469 if (r == ERROR_SUCCESS) continue;
1470
1471 r = MsiQueryComponentStateW( package->ProductCode, NULL,
1472 MSIINSTALLCONTEXT_USERUNMANAGED, comp->ComponentId,
1473 &comp->Installed );
1474 if (r == ERROR_SUCCESS) continue;
1475
1476 r = MsiQueryComponentStateW( package->ProductCode, NULL,
1477 MSIINSTALLCONTEXT_MACHINE, comp->ComponentId,
1478 &comp->Installed );
1479 if (r == ERROR_SUCCESS) continue;
1480
1481 comp->Installed = INSTALLSTATE_ABSENT;
1482 }
1483 }
1484
1485 static void ACTION_GetFeatureInstallStates(MSIPACKAGE *package)
1486 {
1487 MSIFEATURE *feature;
1488
1489 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1490 {
1491 INSTALLSTATE state = MsiQueryFeatureStateW( package->ProductCode, feature->Feature );
1492
1493 if (state == INSTALLSTATE_UNKNOWN || state == INSTALLSTATE_INVALIDARG)
1494 feature->Installed = INSTALLSTATE_ABSENT;
1495 else
1496 feature->Installed = state;
1497 }
1498 }
1499
1500 static inline BOOL is_feature_selected( MSIFEATURE *feature, INT level )
1501 {
1502 return (feature->Level > 0 && feature->Level <= level);
1503 }
1504
1505 static BOOL process_state_property(MSIPACKAGE* package, int level,
1506 LPCWSTR property, INSTALLSTATE state)
1507 {
1508 LPWSTR override;
1509 MSIFEATURE *feature;
1510 BOOL remove = !wcscmp(property, L"REMOVE");
1511 BOOL reinstall = !wcscmp(property, L"REINSTALL");
1512
1513 override = msi_dup_property( package->db, property );
1514 if (!override)
1515 return FALSE;
1516
1517 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1518 {
1519 if (feature->Level <= 0)
1520 continue;
1521
1522 if (reinstall)
1523 state = (feature->Installed == INSTALLSTATE_ABSENT ? INSTALLSTATE_UNKNOWN : feature->Installed);
1524 else if (remove)
1525 state = (feature->Installed == INSTALLSTATE_ABSENT ? INSTALLSTATE_UNKNOWN : INSTALLSTATE_ABSENT);
1526
1527 if (!wcsicmp( override, L"ALL" ))
1528 {
1529 feature->Action = state;
1530 feature->ActionRequest = state;
1531 }
1532 else
1533 {
1534 LPWSTR ptr = override;
1535 LPWSTR ptr2 = wcschr(override,',');
1536
1537 while (ptr)
1538 {
1539 int len = ptr2 - ptr;
1540
1541 if ((ptr2 && lstrlenW(feature->Feature) == len && !wcsncmp(ptr, feature->Feature, len))
1542 || (!ptr2 && !wcscmp(ptr, feature->Feature)))
1543 {
1544 feature->Action = state;
1545 feature->ActionRequest = state;
1546 break;
1547 }
1548 if (ptr2)
1549 {
1550 ptr=ptr2+1;
1551 ptr2 = wcschr(ptr,',');
1552 }
1553 else
1554 break;
1555 }
1556 }
1557 }
1558 msi_free(override);
1559 return TRUE;
1560 }
1561
1562 static BOOL process_overrides( MSIPACKAGE *package, int level )
1563 {
1564 BOOL ret = FALSE;
1565
1566 /* all these activation/deactivation things happen in order and things
1567 * later on the list override things earlier on the list.
1568 *
1569 * 0 INSTALLLEVEL processing
1570 * 1 ADDLOCAL
1571 * 2 REMOVE
1572 * 3 ADDSOURCE
1573 * 4 ADDDEFAULT
1574 * 5 REINSTALL
1575 * 6 ADVERTISE
1576 * 7 COMPADDLOCAL
1577 * 8 COMPADDSOURCE
1578 * 9 FILEADDLOCAL
1579 * 10 FILEADDSOURCE
1580 * 11 FILEADDDEFAULT
1581 */
1582 ret |= process_state_property( package, level, L"ADDLOCAL", INSTALLSTATE_LOCAL );
1583 ret |= process_state_property( package, level, L"REMOVE", INSTALLSTATE_ABSENT );
1584 ret |= process_state_property( package, level, L"ADDSOURCE", INSTALLSTATE_SOURCE );
1585 ret |= process_state_property( package, level, L"REINSTALL", INSTALLSTATE_UNKNOWN );
1586 ret |= process_state_property( package, level, L"ADVERTISE", INSTALLSTATE_ADVERTISED );
1587
1588 if (ret)
1589 msi_set_property( package->db, L"Preselected", L"1", -1 );
1590
1591 return ret;
1592 }
1593
1594 static void disable_children( MSIFEATURE *feature, int level )
1595 {
1596 FeatureList *fl;
1597
1598 LIST_FOR_EACH_ENTRY( fl, &feature->Children, FeatureList, entry )
1599 {
1600 if (!is_feature_selected( feature, level ))
1601 {
1602 TRACE("child %s (level %d request %d) follows disabled parent %s (level %d request %d)\n",
1603 debugstr_w(fl->feature->Feature), fl->feature->Level, fl->feature->ActionRequest,
1604 debugstr_w(feature->Feature), feature->Level, feature->ActionRequest);
1605
1606 fl->feature->Level = feature->Level;
1607 fl->feature->Action = INSTALLSTATE_UNKNOWN;
1608 fl->feature->ActionRequest = INSTALLSTATE_UNKNOWN;
1609 }
1610 disable_children( fl->feature, level );
1611 }
1612 }
1613
1614 static void follow_parent( MSIFEATURE *feature )
1615 {
1616 FeatureList *fl;
1617
1618 LIST_FOR_EACH_ENTRY( fl, &feature->Children, FeatureList, entry )
1619 {
1620 if (fl->feature->Attributes & msidbFeatureAttributesFollowParent)
1621 {
1622 TRACE("child %s (level %d request %d) follows parent %s (level %d request %d)\n",
1623 debugstr_w(fl->feature->Feature), fl->feature->Level, fl->feature->ActionRequest,
1624 debugstr_w(feature->Feature), feature->Level, feature->ActionRequest);
1625
1626 fl->feature->Action = feature->Action;
1627 fl->feature->ActionRequest = feature->ActionRequest;
1628 }
1629 follow_parent( fl->feature );
1630 }
1631 }
1632
1633 UINT MSI_SetFeatureStates(MSIPACKAGE *package)
1634 {
1635 int level;
1636 MSICOMPONENT* component;
1637 MSIFEATURE *feature;
1638
1639 TRACE("Checking Install Level\n");
1640
1641 level = msi_get_property_int(package->db, L"INSTALLLEVEL", 1);
1642
1643 if (msi_get_property_int( package->db, L"Preselected", 0 ))
1644 {
1645 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1646 {
1647 if (!is_feature_selected( feature, level )) continue;
1648
1649 if (feature->ActionRequest == INSTALLSTATE_UNKNOWN)
1650 {
1651 if (feature->Installed == INSTALLSTATE_ABSENT)
1652 {
1653 feature->Action = INSTALLSTATE_UNKNOWN;
1654 feature->ActionRequest = INSTALLSTATE_UNKNOWN;
1655 }
1656 else
1657 {
1658 feature->Action = feature->Installed;
1659 feature->ActionRequest = feature->Installed;
1660 }
1661 }
1662 }
1663 }
1664 else if (!msi_get_property_int( package->db, L"Installed", 0 ))
1665 {
1666 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1667 {
1668 if (!is_feature_selected( feature, level )) continue;
1669
1670 if (feature->ActionRequest == INSTALLSTATE_UNKNOWN)
1671 {
1672 if (feature->Attributes & msidbFeatureAttributesFavorSource)
1673 {
1674 feature->Action = INSTALLSTATE_SOURCE;
1675 feature->ActionRequest = INSTALLSTATE_SOURCE;
1676 }
1677 else if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1678 {
1679 feature->Action = INSTALLSTATE_ADVERTISED;
1680 feature->ActionRequest = INSTALLSTATE_ADVERTISED;
1681 }
1682 else
1683 {
1684 feature->Action = INSTALLSTATE_LOCAL;
1685 feature->ActionRequest = INSTALLSTATE_LOCAL;
1686 }
1687 }
1688 }
1689 }
1690 else
1691 {
1692 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1693 {
1694 ComponentList *cl;
1695 MSIFEATURE *cur;
1696
1697 if (!is_feature_selected( feature, level )) continue;
1698 if (feature->ActionRequest != INSTALLSTATE_UNKNOWN) continue;
1699
1700 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1701 {
1702 if (!cl->component->updated && !cl->component->added)
1703 continue;
1704
1705 cur = feature;
1706 while (cur)
1707 {
1708 if (cur->ActionRequest != INSTALLSTATE_UNKNOWN)
1709 break;
1710
1711 if (cur->Installed != INSTALLSTATE_ABSENT)
1712 {
1713 cur->Action = cur->Installed;
1714 cur->ActionRequest = cur->Installed;
1715 }
1716 else if (!cl->component->added)
1717 {
1718 break;
1719 }
1720 else if (cur->Attributes & msidbFeatureAttributesFavorSource)
1721 {
1722 cur->Action = INSTALLSTATE_SOURCE;
1723 cur->ActionRequest = INSTALLSTATE_SOURCE;
1724 }
1725 else if (cur->Attributes & msidbFeatureAttributesFavorAdvertise)
1726 {
1727 cur->Action = INSTALLSTATE_ADVERTISED;
1728 cur->ActionRequest = INSTALLSTATE_ADVERTISED;
1729 }
1730 else
1731 {
1732 cur->Action = INSTALLSTATE_LOCAL;
1733 cur->ActionRequest = INSTALLSTATE_LOCAL;
1734 }
1735
1736 if (!cur->Feature_Parent)
1737 break;
1738 cur = msi_get_loaded_feature(package, cur->Feature_Parent);
1739 }
1740 }
1741 }
1742 }
1743
1744 /* disable child features of unselected parent or follow parent */
1745 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1746 {
1747 if (feature->Feature_Parent) continue;
1748 disable_children( feature, level );
1749 follow_parent( feature );
1750 }
1751
1752 /* now we want to set component state based based on feature state */
1753 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
1754 {
1755 ComponentList *cl;
1756
1757 TRACE("examining feature %s (level %d installed %d request %d action %d)\n",
1758 debugstr_w(feature->Feature), feature->Level, feature->Installed,
1759 feature->ActionRequest, feature->Action);
1760
1761 /* features with components that have compressed files are made local */
1762 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1763 {
1764 if (cl->component->ForceLocalState &&
1765 feature->ActionRequest == INSTALLSTATE_SOURCE)
1766 {
1767 feature->Action = INSTALLSTATE_LOCAL;
1768 feature->ActionRequest = INSTALLSTATE_LOCAL;
1769 break;
1770 }
1771 }
1772
1773 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
1774 {
1775 component = cl->component;
1776
1777 switch (feature->ActionRequest)
1778 {
1779 case INSTALLSTATE_ABSENT:
1780 component->anyAbsent = 1;
1781 break;
1782 case INSTALLSTATE_ADVERTISED:
1783 component->hasAdvertisedFeature = 1;
1784 break;
1785 case INSTALLSTATE_SOURCE:
1786 component->hasSourceFeature = 1;
1787 break;
1788 case INSTALLSTATE_LOCAL:
1789 component->hasLocalFeature = 1;
1790 break;
1791 case INSTALLSTATE_DEFAULT:
1792 if (feature->Attributes & msidbFeatureAttributesFavorAdvertise)
1793 component->hasAdvertisedFeature = 1;
1794 else if (feature->Attributes & msidbFeatureAttributesFavorSource)
1795 component->hasSourceFeature = 1;
1796 else
1797 component->hasLocalFeature = 1;
1798 break;
1799 case INSTALLSTATE_UNKNOWN:
1800 if (feature->Installed == INSTALLSTATE_ADVERTISED)
1801 component->hasAdvertisedFeature = 1;
1802 if (feature->Installed == INSTALLSTATE_SOURCE)
1803 component->hasSourceFeature = 1;
1804 if (feature->Installed == INSTALLSTATE_LOCAL)
1805 component->hasLocalFeature = 1;
1806 break;
1807 default:
1808 break;
1809 }
1810 }
1811 }
1812
1813 LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1814 {
1815 /* check if it's local or source */
1816 if (!(component->Attributes & msidbComponentAttributesOptional) &&
1817 (component->hasLocalFeature || component->hasSourceFeature))
1818 {
1819 if ((component->Attributes & msidbComponentAttributesSourceOnly) &&
1820 !component->ForceLocalState)
1821 {
1822 component->Action = INSTALLSTATE_SOURCE;
1823 component->ActionRequest = INSTALLSTATE_SOURCE;
1824 }
1825 else
1826 {
1827 component->Action = INSTALLSTATE_LOCAL;
1828 component->ActionRequest = INSTALLSTATE_LOCAL;
1829 }
1830 continue;
1831 }
1832
1833 /* if any feature is local, the component must be local too */
1834 if (component->hasLocalFeature)
1835 {
1836 component->Action = INSTALLSTATE_LOCAL;
1837 component->ActionRequest = INSTALLSTATE_LOCAL;
1838 continue;
1839 }
1840 if (component->hasSourceFeature)
1841 {
1842 component->Action = INSTALLSTATE_SOURCE;
1843 component->ActionRequest = INSTALLSTATE_SOURCE;
1844 continue;
1845 }
1846 if (component->hasAdvertisedFeature)
1847 {
1848 component->Action = INSTALLSTATE_ADVERTISED;
1849 component->ActionRequest = INSTALLSTATE_ADVERTISED;
1850 continue;
1851 }
1852 TRACE("nobody wants component %s\n", debugstr_w(component->Component));
1853 if (component->anyAbsent && component->ComponentId)
1854 {
1855 component->Action = INSTALLSTATE_ABSENT;
1856 component->ActionRequest = INSTALLSTATE_ABSENT;
1857 }
1858 }
1859
1860 LIST_FOR_EACH_ENTRY( component, &package->components, MSICOMPONENT, entry )
1861 {
1862 if (component->ActionRequest == INSTALLSTATE_DEFAULT)
1863 {
1864 TRACE("%s was default, setting to local\n", debugstr_w(component->Component));
1865 component->Action = INSTALLSTATE_LOCAL;
1866 component->ActionRequest = INSTALLSTATE_LOCAL;
1867 }
1868
1869 if (component->ActionRequest == INSTALLSTATE_SOURCE &&
1870 component->Installed == INSTALLSTATE_SOURCE &&
1871 component->hasSourceFeature)
1872 {
1873 component->Action = INSTALLSTATE_UNKNOWN;
1874 component->ActionRequest = INSTALLSTATE_UNKNOWN;
1875 }
1876
1877 if (component->Action == INSTALLSTATE_LOCAL || component->Action == INSTALLSTATE_SOURCE)
1878 component->num_clients++;
1879 else if (component->Action == INSTALLSTATE_ABSENT)
1880 {
1881 component->num_clients--;
1882
1883 if (component->num_clients > 0)
1884 {
1885 TRACE("multiple clients uses %s - disallowing uninstallation\n", debugstr_w(component->Component));
1886 component->Action = INSTALLSTATE_UNKNOWN;
1887 }
1888 }
1889
1890 TRACE("component %s (installed %d request %d action %d)\n",
1891 debugstr_w(component->Component), component->Installed, component->ActionRequest, component->Action);
1892 }
1893
1894 return ERROR_SUCCESS;
1895 }
1896
1897 static UINT ITERATE_CostFinalizeConditions(MSIRECORD *row, LPVOID param)
1898 {
1899 MSIPACKAGE *package = param;
1900 LPCWSTR name;
1901 MSIFEATURE *feature;
1902
1903 name = MSI_RecordGetString( row, 1 );
1904
1905 feature = msi_get_loaded_feature( package, name );
1906 if (!feature)
1907 ERR("FAILED to find loaded feature %s\n",debugstr_w(name));
1908 else
1909 {
1910 LPCWSTR Condition;
1911 Condition = MSI_RecordGetString(row,3);
1912
1913 if (MSI_EvaluateConditionW(package,Condition) == MSICONDITION_TRUE)
1914 {
1915 int level = MSI_RecordGetInteger(row,2);
1916 TRACE("Resetting feature %s to level %i\n", debugstr_w(name), level);
1917 feature->Level = level;
1918 }
1919 }
1920 return ERROR_SUCCESS;
1921 }
1922
1923 int msi_compare_file_versions( VS_FIXEDFILEINFO *fi, const WCHAR *version )
1924 {
1925 DWORD ms, ls;
1926
1927 msi_parse_version_string( version, &ms, &ls );
1928
1929 if (fi->dwFileVersionMS > ms) return 1;
1930 else if (fi->dwFileVersionMS < ms) return -1;
1931 else if (fi->dwFileVersionLS > ls) return 1;
1932 else if (fi->dwFileVersionLS < ls) return -1;
1933 return 0;
1934 }
1935
1936 int msi_compare_font_versions( const WCHAR *ver1, const WCHAR *ver2 )
1937 {
1938 DWORD ms1, ms2;
1939
1940 msi_parse_version_string( ver1, &ms1, NULL );
1941 msi_parse_version_string( ver2, &ms2, NULL );
1942
1943 if (ms1 > ms2) return 1;
1944 else if (ms1 < ms2) return -1;
1945 return 0;
1946 }
1947
1948 static WCHAR *create_temp_dir( MSIDATABASE *db )
1949 {
1950 static UINT id;
1951 WCHAR *ret;
1952
1953 if (!db->tempfolder)
1954 {
1955 WCHAR tmp[MAX_PATH];
1956 UINT len = ARRAY_SIZE( tmp );
1957
1958 if (msi_get_property( db, L"TempFolder", tmp, &len ) ||
1959 GetFileAttributesW( tmp ) != FILE_ATTRIBUTE_DIRECTORY)
1960 {
1961 GetTempPathW( MAX_PATH, tmp );
1962 }
1963 if (!(db->tempfolder = strdupW( tmp ))) return NULL;
1964 }
1965
1966 if ((ret = msi_alloc( (lstrlenW( db->tempfolder ) + 20) * sizeof(WCHAR) )))
1967 {
1968 for (;;)
1969 {
1970 if (!GetTempFileNameW( db->tempfolder, L"msi", ++id, ret ))
1971 {
1972 msi_free( ret );
1973 return NULL;
1974 }
1975 if (CreateDirectoryW( ret, NULL )) break;
1976 }
1977 }
1978
1979 return ret;
1980 }
1981
1982 /*
1983 * msi_build_directory_name()
1984 *
1985 * This function is to save messing round with directory names
1986 * It handles adding backslashes between path segments,
1987 * and can add \ at the end of the directory name if told to.
1988 *
1989 * It takes a variable number of arguments.
1990 * It always allocates a new string for the result, so make sure
1991 * to free the return value when finished with it.
1992 *
1993 * The first arg is the number of path segments that follow.
1994 * The arguments following count are a list of path segments.
1995 * A path segment may be NULL.
1996 *
1997 * Path segments will be added with a \ separating them.
1998 * A \ will not be added after the last segment, however if the
1999 * last segment is NULL, then the last character will be a \
2000 */
2001 WCHAR *msi_build_directory_name( DWORD count, ... )
2002 {
2003 DWORD sz = 1, i;
2004 WCHAR *dir;
2005 va_list va;
2006
2007 va_start( va, count );
2008 for (i = 0; i < count; i++)
2009 {
2010 const WCHAR *str = va_arg( va, const WCHAR * );
2011 if (str) sz += lstrlenW( str ) + 1;
2012 }
2013 va_end( va );
2014
2015 dir = msi_alloc( sz * sizeof(WCHAR) );
2016 dir[0] = 0;
2017
2018 va_start( va, count );
2019 for (i = 0; i < count; i++)
2020 {
2021 const WCHAR *str = va_arg( va, const WCHAR * );
2022 if (!str) continue;
2023 lstrcatW( dir, str );
2024 if ( i + 1 != count && dir[0] && dir[lstrlenW( dir ) - 1] != '\\') lstrcatW( dir, L"\\" );
2025 }
2026 va_end( va );
2027 return dir;
2028 }
2029
2030 BOOL msi_is_global_assembly( MSICOMPONENT *comp )
2031 {
2032 return comp->assembly && !comp->assembly->application;
2033 }
2034
2035 static void set_target_path( MSIPACKAGE *package, MSIFILE *file )
2036 {
2037 msi_free( file->TargetPath );
2038 if (msi_is_global_assembly( file->Component ))
2039 {
2040 MSIASSEMBLY *assembly = file->Component->assembly;
2041
2042 if (!assembly->tempdir) assembly->tempdir = create_temp_dir( package->db );
2043 file->TargetPath = msi_build_directory_name( 2, assembly->tempdir, file->FileName );
2044 }
2045 else
2046 {
2047 const WCHAR *dir = msi_get_target_folder( package, file->Component->Directory );
2048 file->TargetPath = msi_build_directory_name( 2, dir, file->FileName );
2049 }
2050
2051 TRACE("file %s resolves to %s\n", debugstr_w(file->File), debugstr_w(file->TargetPath));
2052 }
2053
2054 static UINT calculate_file_cost( MSIPACKAGE *package )
2055 {
2056 VS_FIXEDFILEINFO *file_version;
2057 WCHAR *font_version;
2058 MSIFILE *file;
2059
2060 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
2061 {
2062 MSICOMPONENT *comp = file->Component;
2063 DWORD file_size;
2064
2065 if (!comp->Enabled) continue;
2066
2067 if (file->IsCompressed)
2068 comp->ForceLocalState = TRUE;
2069
2070 set_target_path( package, file );
2071
2072 if ((comp->assembly && !comp->assembly->installed) ||
2073 msi_get_file_attributes( package, file->TargetPath ) == INVALID_FILE_ATTRIBUTES)
2074 {
2075 comp->Cost += file->FileSize;
2076 continue;
2077 }
2078 file_size = msi_get_disk_file_size( package, file->TargetPath );
2079 TRACE("%s (size %u)\n", debugstr_w(file->TargetPath), file_size);
2080
2081 if (file->Version)
2082 {
2083 if ((file_version = msi_get_disk_file_version( package, file->TargetPath )))
2084 {
2085 if (msi_compare_file_versions( file_version, file->Version ) < 0)
2086 {
2087 comp->Cost += file->FileSize - file_size;
2088 }
2089 msi_free( file_version );
2090 continue;
2091 }
2092 else if ((font_version = msi_get_font_file_version( package, file->TargetPath )))
2093 {
2094 if (msi_compare_font_versions( font_version, file->Version ) < 0)
2095 {
2096 comp->Cost += file->FileSize - file_size;
2097 }
2098 msi_free( font_version );
2099 continue;
2100 }
2101 }
2102 if (file_size != file->FileSize)
2103 {
2104 comp->Cost += file->FileSize - file_size;
2105 }
2106 }
2107
2108 return ERROR_SUCCESS;
2109 }
2110
2111 WCHAR *msi_normalize_path( const WCHAR *in )
2112 {
2113 const WCHAR *p = in;
2114 WCHAR *q, *ret;
2115 int n, len = lstrlenW( in ) + 2;
2116
2117 if (!(q = ret = msi_alloc( len * sizeof(WCHAR) ))) return NULL;
2118
2119 len = 0;
2120 while (1)
2121 {
2122 /* copy until the end of the string or a space */
2123 while (*p != ' ' && (*q = *p))
2124 {
2125 p++, len++;
2126 /* reduce many backslashes to one */
2127 if (*p != '\\' || *q != '\\')
2128 q++;
2129 }
2130
2131 /* quit at the end of the string */
2132 if (!*p)
2133 break;
2134
2135 /* count the number of spaces */
2136 n = 0;
2137 while (p[n] == ' ')
2138 n++;
2139
2140 /* if it's leading or trailing space, skip it */
2141 if ( len == 0 || p[-1] == '\\' || p[n] == '\\' )
2142 p += n;
2143 else /* copy n spaces */
2144 while (n && (*q++ = *p++)) n--;
2145 }
2146 while (q - ret > 0 && q[-1] == ' ') q--;
2147 if (q - ret > 0 && q[-1] != '\\')
2148 {
2149 q[0] = '\\';
2150 q[1] = 0;
2151 }
2152 return ret;
2153 }
2154
2155 static WCHAR *get_install_location( MSIPACKAGE *package )
2156 {
2157 HKEY hkey;
2158 WCHAR *path;
2159
2160 if (!package->ProductCode) return NULL;
2161 if (MSIREG_OpenInstallProps( package->ProductCode, package->Context, NULL, &hkey, FALSE )) return NULL;
2162 if ((path = msi_reg_get_val_str( hkey, L"InstallLocation" )) && !path[0])
2163 {
2164 msi_free( path );
2165 path = NULL;
2166 }
2167 RegCloseKey( hkey );
2168 return path;
2169 }
2170
2171 void msi_resolve_target_folder( MSIPACKAGE *package, const WCHAR *name, BOOL load_prop )
2172 {
2173 FolderList *fl;
2174 MSIFOLDER *folder, *parent, *child;
2175 WCHAR *path, *normalized_path;
2176
2177 TRACE("resolving %s\n", debugstr_w(name));
2178
2179 if (!(folder = msi_get_loaded_folder( package, name ))) return;
2180
2181 if (!wcscmp( folder->Directory, L"TARGETDIR" )) /* special resolving for target root dir */
2182 {
2183 if (!(path = get_install_location( package )) &&
2184 (!load_prop || !(path = msi_dup_property( package->db, L"TARGETDIR" ))))
2185 {
2186 path = msi_dup_property( package->db, L"ROOTDRIVE" );
2187 }
2188 }
2189 else if (!load_prop || !(path = msi_dup_property( package->db, folder->Directory )))
2190 {
2191 if (folder->Parent && wcscmp( folder->Directory, folder->Parent ))
2192 {
2193 parent = msi_get_loaded_folder( package, folder->Parent );
2194 path = msi_build_directory_name( 3, parent->ResolvedTarget, folder->TargetDefault, NULL );
2195 }
2196 else
2197 path = msi_build_directory_name( 2, folder->TargetDefault, NULL );
2198 }
2199
2200 normalized_path = msi_normalize_path( path );
2201 msi_set_property( package->db, folder->Directory, normalized_path, -1 );
2202 msi_free( path );
2203
2204 msi_free( folder->ResolvedTarget );
2205 folder->ResolvedTarget = normalized_path;
2206
2207 LIST_FOR_EACH_ENTRY( fl, &folder->children, FolderList, entry )
2208 {
2209 child = fl->folder;
2210 msi_resolve_target_folder( package, child->Directory, load_prop );
2211 }
2212 TRACE("%s resolves to %s\n", debugstr_w(name), debugstr_w(folder->ResolvedTarget));
2213 }
2214
2215 static ULONGLONG get_volume_space_required( MSIPACKAGE *package )
2216 {
2217 MSICOMPONENT *comp;
2218 ULONGLONG ret = 0;
2219
2220 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2221 {
2222 if (comp->Action == INSTALLSTATE_LOCAL) ret += comp->Cost;
2223 }
2224 return ret;
2225 }
2226
2227 static UINT ACTION_CostFinalize(MSIPACKAGE *package)
2228 {
2229 MSICOMPONENT *comp;
2230 MSIQUERY *view;
2231 WCHAR *level, *primary_key, *primary_folder;
2232 UINT rc;
2233
2234 TRACE("Building directory properties\n");
2235 msi_resolve_target_folder( package, L"TARGETDIR", TRUE );
2236
2237 TRACE("Evaluating component conditions\n");
2238 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
2239 {
2240 if (MSI_EvaluateConditionW( package, comp->Condition ) == MSICONDITION_FALSE)
2241 {
2242 TRACE("Disabling component %s\n", debugstr_w(comp->Component));
2243 comp->Enabled = FALSE;
2244 }
2245 else
2246 comp->Enabled = TRUE;
2247 }
2248 get_client_counts( package );
2249
2250 /* read components states from the registry */
2251 ACTION_GetComponentInstallStates(package);
2252 ACTION_GetFeatureInstallStates(package);
2253
2254 if (!process_overrides( package, msi_get_property_int( package->db, L"INSTALLLEVEL", 1 ) ))
2255 {
2256 TRACE("Evaluating feature conditions\n");
2257
2258 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Condition`", &view );
2259 if (rc == ERROR_SUCCESS)
2260 {
2261 rc = MSI_IterateRecords( view, NULL, ITERATE_CostFinalizeConditions, package );
2262 msiobj_release( &view->hdr );
2263 if (rc != ERROR_SUCCESS)
2264 return rc;
2265 }
2266 }
2267
2268 TRACE("Calculating file cost\n");
2269 calculate_file_cost( package );
2270
2271 msi_set_property( package->db, L"CostingComplete", L"1", -1 );
2272 /* set default run level if not set */
2273 level = msi_dup_property( package->db, L"INSTALLLEVEL" );
2274 if (!level) msi_set_property( package->db, L"INSTALLLEVEL", L"1", -1 );
2275 msi_free(level);
2276
2277 if ((rc = MSI_SetFeatureStates( package ))) return rc;
2278
2279 if ((primary_key = msi_dup_property( package->db, L"PRIMARYFOLDER" )))
2280 {
2281 if ((primary_folder = msi_dup_property( package->db, primary_key )))
2282 {
2283 if (((primary_folder[0] >= 'A' && primary_folder[0] <= 'Z') ||
2284 (primary_folder[0] >= 'a' && primary_folder[0] <= 'z')) && primary_folder[1] == ':')
2285 {
2286 ULARGE_INTEGER free;
2287 ULONGLONG required;
2288 WCHAR buf[21];
2289
2290 primary_folder[2] = 0;
2291 if (GetDiskFreeSpaceExW( primary_folder, &free, NULL, NULL ))
2292 {
2293 swprintf( buf, ARRAY_SIZE(buf), L"%lu", free.QuadPart / 512 );
2294 msi_set_property( package->db, L"PrimaryVolumeSpaceAvailable", buf, -1 );
2295 }
2296 required = get_volume_space_required( package );
2297 swprintf( buf, ARRAY_SIZE(buf), L"%lu", required / 512 );
2298 msi_set_property( package->db, L"PrimaryVolumeSpaceRequired", buf, -1 );
2299
2300 swprintf( buf, ARRAY_SIZE(buf), L"%lu", (free.QuadPart - required) / 512 );
2301 msi_set_property( package->db, L"PrimaryVolumeSpaceRemaining", buf, -1 );
2302 msi_set_property( package->db, L"PrimaryVolumePath", primary_folder, 2 );
2303 }
2304 msi_free( primary_folder );
2305 }
2306 msi_free( primary_key );
2307 }
2308
2309 /* FIXME: check volume disk space */
2310 msi_set_property( package->db, L"OutOfDiskSpace", L"0", -1 );
2311 msi_set_property( package->db, L"OutOfNoRbDiskSpace", L"0", -1 );
2312
2313 return ERROR_SUCCESS;
2314 }
2315
2316 static BYTE *parse_value( MSIPACKAGE *package, const WCHAR *value, DWORD len, DWORD *type, DWORD *size )
2317 {
2318 BYTE *data;
2319
2320 if (!value)
2321 {
2322 *size = sizeof(WCHAR);
2323 *type = REG_SZ;
2324 if ((data = msi_alloc( *size ))) *(WCHAR *)data = 0;
2325 return data;
2326 }
2327 if (value[0]=='#' && value[1]!='#' && value[1]!='%')
2328 {
2329 if (value[1]=='x')
2330 {
2331 LPWSTR ptr;
2332 CHAR byte[5];
2333 LPWSTR deformated = NULL;
2334 int count;
2335
2336 deformat_string(package, &value[2], &deformated);
2337
2338 /* binary value type */
2339 ptr = deformated;
2340 *type = REG_BINARY;
2341 if (lstrlenW(ptr)%2)
2342 *size = (lstrlenW(ptr)/2)+1;
2343 else
2344 *size = lstrlenW(ptr)/2;
2345
2346 data = msi_alloc(*size);
2347
2348 byte[0] = '0';
2349 byte[1] = 'x';
2350 byte[4] = 0;
2351 count = 0;
2352 /* if uneven pad with a zero in front */
2353 if (lstrlenW(ptr)%2)
2354 {
2355 byte[2]= '0';
2356 byte[3]= *ptr;
2357 ptr++;
2358 data[count] = (BYTE)strtol(byte,NULL,0);
2359 count ++;
2360 TRACE("Uneven byte count\n");
2361 }
2362 while (*ptr)
2363 {
2364 byte[2]= *ptr;
2365 ptr++;
2366 byte[3]= *ptr;
2367 ptr++;
2368 data[count] = (BYTE)strtol(byte,NULL,0);
2369 count ++;
2370 }
2371 msi_free(deformated);
2372
2373 TRACE("Data %i bytes(%i)\n",*size,count);
2374 }
2375 else
2376 {
2377 LPWSTR deformated;
2378 LPWSTR p;
2379 DWORD d = 0;
2380 deformat_string(package, &value[1], &deformated);
2381
2382 *type=REG_DWORD;
2383 *size = sizeof(DWORD);
2384 data = msi_alloc(*size);
2385 p = deformated;
2386 if (*p == '-')
2387 p++;
2388 while (*p)
2389 {
2390 if ( (*p < '0') || (*p > '9') )
2391 break;
2392 d *= 10;
2393 d += (*p - '0');
2394 p++;
2395 }
2396 if (deformated[0] == '-')
2397 d = -d;
2398 *(LPDWORD)data = d;
2399 TRACE("DWORD %i\n",*(LPDWORD)data);
2400
2401 msi_free(deformated);
2402 }
2403 }
2404 else
2405 {
2406 const WCHAR *ptr = value;
2407
2408 *type = REG_SZ;
2409 if (value[0] == '#')
2410 {
2411 ptr++; len--;
2412 if (value[1] == '%')
2413 {
2414 ptr++; len--;
2415 *type = REG_EXPAND_SZ;
2416 }
2417 }
2418 data = (BYTE *)msi_strdupW( ptr, len );
2419 if (len > lstrlenW( (const WCHAR *)data )) *type = REG_MULTI_SZ;
2420 *size = (len + 1) * sizeof(WCHAR);
2421 }
2422 return data;
2423 }
2424
2425 static const WCHAR *get_root_key( MSIPACKAGE *package, INT root, HKEY *root_key )
2426 {
2427 const WCHAR *ret;
2428
2429 switch (root)
2430 {
2431 case -1:
2432 if (msi_get_property_int( package->db, L"ALLUSERS", 0 ))
2433 {
2434 *root_key = HKEY_LOCAL_MACHINE;
2435 ret = L"HKEY_LOCAL_MACHINE\\";
2436 }
2437 else
2438 {
2439 *root_key = HKEY_CURRENT_USER;
2440 ret = L"HKEY_CURRENT_USER\\";
2441 }
2442 break;
2443 case 0:
2444 *root_key = HKEY_CLASSES_ROOT;
2445 ret = L"HKEY_CLASSES_ROOT\\";
2446 break;
2447 case 1:
2448 *root_key = HKEY_CURRENT_USER;
2449 ret = L"HKEY_CURRENT_USER\\";
2450 break;
2451 case 2:
2452 *root_key = HKEY_LOCAL_MACHINE;
2453 ret = L"HKEY_LOCAL_MACHINE\\";
2454 break;
2455 case 3:
2456 *root_key = HKEY_USERS;
2457 ret = L"HKEY_USERS\\";
2458 break;
2459 default:
2460 ERR("Unknown root %i\n", root);
2461 return NULL;
2462 }
2463
2464 return ret;
2465 }
2466
2467 static inline REGSAM get_registry_view( const MSICOMPONENT *comp )
2468 {
2469 REGSAM view = 0;
2470 if (is_wow64 || is_64bit)
2471 view |= (comp->Attributes & msidbComponentAttributes64bit) ? KEY_WOW64_64KEY : KEY_WOW64_32KEY;
2472 return view;
2473 }
2474
2475 static HKEY open_key( const MSICOMPONENT *comp, HKEY root, const WCHAR *path, BOOL create, REGSAM access )
2476 {
2477 WCHAR *subkey, *p, *q;
2478 HKEY hkey, ret = NULL;
2479 LONG res;
2480
2481 access |= get_registry_view( comp );
2482
2483 if (!(subkey = strdupW( path ))) return NULL;
2484 p = subkey;
2485 if ((q = wcschr( p, '\\' ))) *q = 0;
2486 if (create)
2487 res = RegCreateKeyExW( root, subkey, 0, NULL, 0, access, NULL, &hkey, NULL );
2488 else
2489 res = RegOpenKeyExW( root, subkey, 0, access, &hkey );
2490 if (res)
2491 {
2492 TRACE("failed to open key %s (%d)\n", debugstr_w(subkey), res);
2493 msi_free( subkey );
2494 return NULL;
2495 }
2496 if (q && q[1])
2497 {
2498 ret = open_key( comp, hkey, q + 1, create, access );
2499 RegCloseKey( hkey );
2500 }
2501 else ret = hkey;
2502 msi_free( subkey );
2503 return ret;
2504 }
2505
2506 static BOOL is_special_entry( const WCHAR *name )
2507 {
2508 return (name && (name[0] == '*' || name[0] == '+') && !name[1]);
2509 }
2510
2511 static WCHAR **split_multi_string_values( const WCHAR *str, DWORD len, DWORD *count )
2512 {
2513 const WCHAR *p = str;
2514 WCHAR **ret;
2515 int i = 0;
2516
2517 *count = 0;
2518 if (!str) return NULL;
2519 while ((p - str) < len)
2520 {
2521 p += lstrlenW( p ) + 1;
2522 (*count)++;
2523 }
2524 if (!(ret = msi_alloc( *count * sizeof(WCHAR *) ))) return NULL;
2525 p = str;
2526 while ((p - str) < len)
2527 {
2528 if (!(ret[i] = strdupW( p )))
2529 {
2530 for (; i >= 0; i--) msi_free( ret[i] );
2531 msi_free( ret );
2532 return NULL;
2533 }
2534 p += lstrlenW( p ) + 1;
2535 i++;
2536 }
2537 return ret;
2538 }
2539
2540 static WCHAR *flatten_multi_string_values( WCHAR **left, DWORD left_count,
2541 WCHAR **right, DWORD right_count, DWORD *size )
2542 {
2543 WCHAR *ret, *p;
2544 unsigned int i;
2545
2546 *size = sizeof(WCHAR);
2547 for (i = 0; i < left_count; i++) *size += (lstrlenW( left[i] ) + 1) * sizeof(WCHAR);
2548 for (i = 0; i < right_count; i++) *size += (lstrlenW( right[i] ) + 1) * sizeof(WCHAR);
2549
2550 if (!(ret = p = msi_alloc( *size ))) return NULL;
2551
2552 for (i = 0; i < left_count; i++)
2553 {
2554 lstrcpyW( p, left[i] );
2555 p += lstrlenW( p ) + 1;
2556 }
2557 for (i = 0; i < right_count; i++)
2558 {
2559 lstrcpyW( p, right[i] );
2560 p += lstrlenW( p ) + 1;
2561 }
2562 *p = 0;
2563 return ret;
2564 }
2565
2566 static DWORD remove_duplicate_values( WCHAR **old, DWORD old_count,
2567 WCHAR **new, DWORD new_count )
2568 {
2569 DWORD ret = old_count;
2570 unsigned int i, j, k;
2571
2572 for (i = 0; i < new_count; i++)
2573 {
2574 for (j = 0; j < old_count; j++)
2575 {
2576 if (old[j] && !wcscmp( new[i], old[j] ))
2577 {
2578 msi_free( old[j] );
2579 for (k = j; k < old_count - 1; k++) { old[k] = old[k + 1]; }
2580 old[k] = NULL;
2581 ret--;
2582 }
2583 }
2584 }
2585 return ret;
2586 }
2587
2588 enum join_op
2589 {
2590 JOIN_OP_APPEND,
2591 JOIN_OP_PREPEND,
2592 JOIN_OP_REPLACE
2593 };
2594
2595 static WCHAR *join_multi_string_values( enum join_op op, WCHAR **old, DWORD old_count,
2596 WCHAR **new, DWORD new_count, DWORD *size )
2597 {
2598 switch (op)
2599 {
2600 case JOIN_OP_APPEND:
2601 old_count = remove_duplicate_values( old, old_count, new, new_count );
2602 return flatten_multi_string_values( old, old_count, new, new_count, size );
2603
2604 case JOIN_OP_PREPEND:
2605 old_count = remove_duplicate_values( old, old_count, new, new_count );
2606 return flatten_multi_string_values( new, new_count, old, old_count, size );
2607
2608 case JOIN_OP_REPLACE:
2609 return flatten_multi_string_values( new, new_count, NULL, 0, size );
2610
2611 default:
2612 ERR("unhandled join op %u\n", op);
2613 return NULL;
2614 }
2615 }
2616
2617 static BYTE *build_multi_string_value( BYTE *old_value, DWORD old_size,
2618 BYTE *new_value, DWORD new_size, DWORD *size )
2619 {
2620 DWORD i, old_len = 0, new_len = 0, old_count = 0, new_count = 0;
2621 const WCHAR *new_ptr = NULL, *old_ptr = NULL;
2622 enum join_op op = JOIN_OP_REPLACE;
2623 WCHAR **old = NULL, **new = NULL;
2624 BYTE *ret;
2625
2626 if (new_size / sizeof(WCHAR) - 1 > 1)
2627 {
2628 new_ptr = (const WCHAR *)new_value;
2629 new_len = new_size / sizeof(WCHAR) - 1;
2630
2631 if (!new_ptr[0] && new_ptr[new_len - 1])
2632 {
2633 op = JOIN_OP_APPEND;
2634 new_len--;
2635 new_ptr++;
2636 }
2637 else if (new_ptr[0] && !new_ptr[new_len - 1])
2638 {
2639 op = JOIN_OP_PREPEND;
2640 new_len--;
2641 }
2642 else if (new_len > 2 && !new_ptr[0] && !new_ptr[new_len - 1])
2643 {
2644 op = JOIN_OP_REPLACE;
2645 new_len -= 2;
2646 new_ptr++;
2647 }
2648 new = split_multi_string_values( new_ptr, new_len, &new_count );
2649 }
2650 if (old_size / sizeof(WCHAR) - 1 > 1)
2651 {
2652 old_ptr = (const WCHAR *)old_value;
2653 old_len = old_size / sizeof(WCHAR) - 1;
2654 old = split_multi_string_values( old_ptr, old_len, &old_count );
2655 }
2656 ret = (BYTE *)join_multi_string_values( op, old, old_count, new, new_count, size );
2657 for (i = 0; i < old_count; i++) msi_free( old[i] );
2658 for (i = 0; i < new_count; i++) msi_free( new[i] );
2659 msi_free( old );
2660 msi_free( new );
2661 return ret;
2662 }
2663
2664 static BYTE *reg_get_value( HKEY hkey, const WCHAR *name, DWORD *type, DWORD *size )
2665 {
2666 BYTE *ret;
2667 if (RegQueryValueExW( hkey, name, NULL, NULL, NULL, size )) return NULL;
2668 if (!(ret = msi_alloc( *size ))) return NULL;
2669 RegQueryValueExW( hkey, name, NULL, type, ret, size );
2670 return ret;
2671 }
2672
2673 static UINT ITERATE_WriteRegistryValues(MSIRECORD *row, LPVOID param)
2674 {
2675 MSIPACKAGE *package = param;
2676 BYTE *new_value, *old_value = NULL;
2677 HKEY root_key, hkey;
2678 DWORD type, old_type, new_size, old_size = 0;
2679 LPWSTR deformated, uikey;
2680 const WCHAR *szRoot, *component, *name, *key, *str;
2681 MSICOMPONENT *comp;
2682 MSIRECORD * uirow;
2683 INT root;
2684 BOOL check_first = FALSE;
2685 int len;
2686
2687 msi_ui_progress( package, 2, REG_PROGRESS_VALUE, 0, 0 );
2688
2689 component = MSI_RecordGetString(row, 6);
2690 comp = msi_get_loaded_component(package,component);
2691 if (!comp)
2692 return ERROR_SUCCESS;
2693
2694 comp->Action = msi_get_component_action( package, comp );
2695 if (comp->Action != INSTALLSTATE_LOCAL && comp->Action != INSTALLSTATE_SOURCE)
2696 {
2697 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
2698 return ERROR_SUCCESS;
2699 }
2700
2701 name = MSI_RecordGetString(row, 4);
2702 if( MSI_RecordIsNull(row,5) && name )
2703 {
2704 /* null values can have special meanings */
2705 if (name[0]=='-' && name[1] == 0)
2706 return ERROR_SUCCESS;
2707 if ((name[0] == '+' || name[0] == '*') && !name[1])
2708 check_first = TRUE;
2709 }
2710
2711 root = MSI_RecordGetInteger(row,2);
2712 key = MSI_RecordGetString(row, 3);
2713
2714 szRoot = get_root_key( package, root, &root_key );
2715 if (!szRoot)
2716 return ERROR_SUCCESS;
2717
2718 deformat_string(package, key , &deformated);
2719 uikey = msi_alloc( (lstrlenW(deformated) + lstrlenW(szRoot) + 1) * sizeof(WCHAR) );
2720 lstrcpyW(uikey,szRoot);
2721 lstrcatW(uikey,deformated);
2722
2723 if (!(hkey = open_key( comp, root_key, deformated, TRUE, KEY_QUERY_VALUE | KEY_SET_VALUE )))
2724 {
2725 ERR("Could not create key %s\n", debugstr_w(deformated));
2726 msi_free(uikey);
2727 msi_free(deformated);
2728 return ERROR_FUNCTION_FAILED;
2729 }
2730 msi_free( deformated );
2731 str = msi_record_get_string( row, 5, NULL );
2732 len = deformat_string( package, str, &deformated );
2733 new_value = parse_value( package, deformated, len, &type, &new_size );
2734
2735 msi_free( deformated );
2736 deformat_string(package, name, &deformated);
2737
2738 if (!is_special_entry( name ))
2739 {
2740 old_value = reg_get_value( hkey, deformated, &old_type, &old_size );
2741 if (type == REG_MULTI_SZ)
2742 {
2743 BYTE *new;
2744 if (old_value && old_type != REG_MULTI_SZ)
2745 {
2746 msi_free( old_value );
2747 old_value = NULL;
2748 old_size = 0;
2749 }
2750 new = build_multi_string_value( old_value, old_size, new_value, new_size, &new_size );
2751 msi_free( new_value );
2752 new_value = new;
2753 }
2754 if (!check_first)
2755 {
2756 TRACE("setting value %s of %s type %u\n", debugstr_w(deformated), debugstr_w(uikey), type);
2757 RegSetValueExW( hkey, deformated, 0, type, new_value, new_size );
2758 }
2759 else if (!old_value)
2760 {
2761 if (deformated || new_size)
2762 {
2763 TRACE("setting value %s of %s type %u\n", debugstr_w(deformated), debugstr_w(uikey), type);
2764 RegSetValueExW( hkey, deformated, 0, type, new_value, new_size );
2765 }
2766 }
2767 else TRACE("not overwriting existing value %s of %s\n", debugstr_w(deformated), debugstr_w(uikey));
2768 }
2769 RegCloseKey(hkey);
2770
2771 uirow = MSI_CreateRecord(3);
2772 MSI_RecordSetStringW(uirow,2,deformated);
2773 MSI_RecordSetStringW(uirow,1,uikey);
2774 if (type == REG_SZ || type == REG_EXPAND_SZ)
2775 MSI_RecordSetStringW(uirow, 3, (LPWSTR)new_value);
2776 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
2777 msiobj_release( &uirow->hdr );
2778
2779 msi_free(new_value);
2780 msi_free(old_value);
2781 msi_free(deformated);
2782 msi_free(uikey);
2783
2784 return ERROR_SUCCESS;
2785 }
2786
2787 static UINT ACTION_WriteRegistryValues(MSIPACKAGE *package)
2788 {
2789 MSIQUERY *view;
2790 UINT rc;
2791
2792 if (package->script == SCRIPT_NONE)
2793 return msi_schedule_action(package, SCRIPT_INSTALL, L"WriteRegistryValues");
2794
2795 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `Registry`", &view);
2796 if (rc != ERROR_SUCCESS)
2797 return ERROR_SUCCESS;
2798
2799 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteRegistryValues, package);
2800 msiobj_release(&view->hdr);
2801 return rc;
2802 }
2803
2804 static int is_key_empty(const MSICOMPONENT *comp, HKEY root, const WCHAR *path)
2805 {
2806 DWORD subkeys, values;
2807 HKEY key;
2808 LONG res;
2809
2810 key = open_key(comp, root, path, FALSE, KEY_READ);
2811 if (!key) return 0;
2812
2813 res = RegQueryInfoKeyW(key, 0, 0, 0, &subkeys, 0, 0, &values, 0, 0, 0, 0);
2814 RegCloseKey(key);
2815
2816 return !res && !subkeys && !values;
2817 }
2818
2819 static void delete_key( const MSICOMPONENT *comp, HKEY root, const WCHAR *path )
2820 {
2821 LONG res = ERROR_SUCCESS;
2822 REGSAM access = get_registry_view( comp );
2823 WCHAR *subkey, *p;
2824 HKEY hkey;
2825
2826 if (!(subkey = strdupW( path ))) return;
2827 do
2828 {
2829 if ((p = wcsrchr( subkey, '\\' )))
2830 {
2831 *p = 0;
2832 if (!p[1]) continue; /* trailing backslash */
2833 hkey = open_key( comp, root, subkey, FALSE, READ_CONTROL );
2834 if (!hkey) break;
2835 if (!is_key_empty(comp, hkey, p + 1))
2836 {
2837 RegCloseKey(hkey);
2838 break;
2839 }
2840 res = RegDeleteKeyExW( hkey, p + 1, access, 0 );
2841 RegCloseKey( hkey );
2842 }
2843 else if (is_key_empty(comp, root, subkey))
2844 res = RegDeleteKeyExW( root, subkey, access, 0 );
2845 if (res)
2846 {
2847 TRACE("failed to delete key %s (%d)\n", debugstr_w(subkey), res);
2848 break;
2849 }
2850 } while (p);
2851 msi_free( subkey );
2852 }
2853
2854 static void delete_value( const MSICOMPONENT *comp, HKEY root, const WCHAR *path, const WCHAR *value )
2855 {
2856 LONG res;
2857 HKEY hkey;
2858
2859 if ((hkey = open_key( comp, root, path, FALSE, KEY_SET_VALUE | KEY_QUERY_VALUE )))
2860 {
2861 if ((res = RegDeleteValueW( hkey, value )))
2862 TRACE("failed to delete value %s (%d)\n", debugstr_w(value), res);
2863
2864 RegCloseKey( hkey );
2865 if (is_key_empty(comp, root, path))
2866 {
2867 TRACE("removing empty key %s\n", debugstr_w(path));
2868 delete_key( comp, root, path );
2869 }
2870 }
2871 }
2872
2873 static void delete_tree( const MSICOMPONENT *comp, HKEY root, const WCHAR *path )
2874 {
2875 LONG res;
2876 HKEY hkey;
2877
2878 if (!(hkey = open_key( comp, root, path, FALSE, KEY_ALL_ACCESS ))) return;
2879 res = RegDeleteTreeW( hkey, NULL );
2880 if (res) TRACE("failed to delete subtree of %s (%d)\n", debugstr_w(path), res);
2881 delete_key( comp, root, path );
2882 RegCloseKey( hkey );
2883 }
2884
2885 static UINT ITERATE_RemoveRegistryValuesOnUninstall( MSIRECORD *row, LPVOID param )
2886 {
2887 MSIPACKAGE *package = param;
2888 LPCWSTR component, name, key_str, root_key_str;
2889 LPWSTR deformated_key, deformated_name, ui_key_str;
2890 MSICOMPONENT *comp;
2891 MSIRECORD *uirow;
2892 BOOL delete_key = FALSE;
2893 HKEY hkey_root;
2894 UINT size;
2895 INT root;
2896
2897 msi_ui_progress( package, 2, REG_PROGRESS_VALUE, 0, 0 );
2898
2899 component = MSI_RecordGetString( row, 6 );
2900 comp = msi_get_loaded_component( package, component );
2901 if (!comp)
2902 return ERROR_SUCCESS;
2903
2904 comp->Action = msi_get_component_action( package, comp );
2905 if (comp->Action != INSTALLSTATE_ABSENT)
2906 {
2907 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
2908 return ERROR_SUCCESS;
2909 }
2910
2911 name = MSI_RecordGetString( row, 4 );
2912 if (MSI_RecordIsNull( row, 5 ) && name )
2913 {
2914 if (name[0] == '+' && !name[1])
2915 return ERROR_SUCCESS;
2916 if ((name[0] == '-' || name[0] == '*') && !name[1])
2917 {
2918 delete_key = TRUE;
2919 name = NULL;
2920 }
2921 }
2922
2923 root = MSI_RecordGetInteger( row, 2 );
2924 key_str = MSI_RecordGetString( row, 3 );
2925
2926 root_key_str = get_root_key( package, root, &hkey_root );
2927 if (!root_key_str)
2928 return ERROR_SUCCESS;
2929
2930 deformat_string( package, key_str, &deformated_key );
2931 size = lstrlenW( deformated_key ) + lstrlenW( root_key_str ) + 1;
2932 ui_key_str = msi_alloc( size * sizeof(WCHAR) );
2933 lstrcpyW( ui_key_str, root_key_str );
2934 lstrcatW( ui_key_str, deformated_key );
2935
2936 deformat_string( package, name, &deformated_name );
2937
2938 if (delete_key) delete_tree( comp, hkey_root, deformated_key );
2939 else delete_value( comp, hkey_root, deformated_key, deformated_name );
2940 msi_free( deformated_key );
2941
2942 uirow = MSI_CreateRecord( 2 );
2943 MSI_RecordSetStringW( uirow, 1, ui_key_str );
2944 MSI_RecordSetStringW( uirow, 2, deformated_name );
2945 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
2946 msiobj_release( &uirow->hdr );
2947
2948 msi_free( ui_key_str );
2949 msi_free( deformated_name );
2950 return ERROR_SUCCESS;
2951 }
2952
2953 static UINT ITERATE_RemoveRegistryValuesOnInstall( MSIRECORD *row, LPVOID param )
2954 {
2955 MSIPACKAGE *package = param;
2956 LPCWSTR component, name, key_str, root_key_str;
2957 LPWSTR deformated_key, deformated_name, ui_key_str;
2958 MSICOMPONENT *comp;
2959 MSIRECORD *uirow;
2960 BOOL delete_key = FALSE;
2961 HKEY hkey_root;
2962 UINT size;
2963 INT root;
2964
2965 component = MSI_RecordGetString( row, 5 );
2966 comp = msi_get_loaded_component( package, component );
2967 if (!comp)
2968 return ERROR_SUCCESS;
2969
2970 comp->Action = msi_get_component_action( package, comp );
2971 if (comp->Action != INSTALLSTATE_LOCAL)
2972 {
2973 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
2974 return ERROR_SUCCESS;
2975 }
2976
2977 if ((name = MSI_RecordGetString( row, 4 )))
2978 {
2979 if (name[0] == '-' && !name[1])
2980 {
2981 delete_key = TRUE;
2982 name = NULL;
2983 }
2984 }
2985
2986 root = MSI_RecordGetInteger( row, 2 );
2987 key_str = MSI_RecordGetString( row, 3 );
2988
2989 root_key_str = get_root_key( package, root, &hkey_root );
2990 if (!root_key_str)
2991 return ERROR_SUCCESS;
2992
2993 deformat_string( package, key_str, &deformated_key );
2994 size = lstrlenW( deformated_key ) + lstrlenW( root_key_str ) + 1;
2995 ui_key_str = msi_alloc( size * sizeof(WCHAR) );
2996 lstrcpyW( ui_key_str, root_key_str );
2997 lstrcatW( ui_key_str, deformated_key );
2998
2999 deformat_string( package, name, &deformated_name );
3000
3001 if (delete_key) delete_tree( comp, hkey_root, deformated_key );
3002 else delete_value( comp, hkey_root, deformated_key, deformated_name );
3003 msi_free( deformated_key );
3004
3005 uirow = MSI_CreateRecord( 2 );
3006 MSI_RecordSetStringW( uirow, 1, ui_key_str );
3007 MSI_RecordSetStringW( uirow, 2, deformated_name );
3008 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
3009 msiobj_release( &uirow->hdr );
3010
3011 msi_free( ui_key_str );
3012 msi_free( deformated_name );
3013 return ERROR_SUCCESS;
3014 }
3015
3016 static UINT ACTION_RemoveRegistryValues( MSIPACKAGE *package )
3017 {
3018 MSIQUERY *view;
3019 UINT rc;
3020
3021 if (package->script == SCRIPT_NONE)
3022 return msi_schedule_action(package, SCRIPT_INSTALL, L"RemoveRegistryValues");
3023
3024 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Registry`", &view );
3025 if (rc == ERROR_SUCCESS)
3026 {
3027 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveRegistryValuesOnUninstall, package );
3028 msiobj_release( &view->hdr );
3029 if (rc != ERROR_SUCCESS)
3030 return rc;
3031 }
3032 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `RemoveRegistry`", &view );
3033 if (rc == ERROR_SUCCESS)
3034 {
3035 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveRegistryValuesOnInstall, package );
3036 msiobj_release( &view->hdr );
3037 if (rc != ERROR_SUCCESS)
3038 return rc;
3039 }
3040 return ERROR_SUCCESS;
3041 }
3042
3043 static UINT ACTION_InstallInitialize(MSIPACKAGE *package)
3044 {
3045 return ERROR_SUCCESS;
3046 }
3047
3048
3049 static UINT ACTION_InstallValidate(MSIPACKAGE *package)
3050 {
3051 MSICOMPONENT *comp;
3052 DWORD total = 0, count = 0;
3053 MSIQUERY *view;
3054 MSIFEATURE *feature;
3055 MSIFILE *file;
3056 UINT rc;
3057
3058 TRACE("InstallValidate\n");
3059
3060 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Registry`", &view );
3061 if (rc == ERROR_SUCCESS)
3062 {
3063 rc = MSI_IterateRecords( view, &count, NULL, package );
3064 msiobj_release( &view->hdr );
3065 if (rc != ERROR_SUCCESS)
3066 return rc;
3067 total += count * REG_PROGRESS_VALUE;
3068 }
3069 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
3070 total += COMPONENT_PROGRESS_VALUE;
3071
3072 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
3073 total += file->FileSize;
3074
3075 msi_ui_progress( package, 0, total, 0, 0 );
3076
3077 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3078 {
3079 TRACE("Feature: %s Installed %d Request %d Action %d\n",
3080 debugstr_w(feature->Feature), feature->Installed,
3081 feature->ActionRequest, feature->Action);
3082 }
3083 return ERROR_SUCCESS;
3084 }
3085
3086 static UINT ITERATE_LaunchConditions(MSIRECORD *row, LPVOID param)
3087 {
3088 MSIPACKAGE* package = param;
3089 const WCHAR *cond, *message;
3090 UINT r;
3091
3092 cond = MSI_RecordGetString(row, 1);
3093 r = MSI_EvaluateConditionW(package, cond);
3094 if (r == MSICONDITION_FALSE)
3095 {
3096 if ((package->ui_level & INSTALLUILEVEL_MASK) != INSTALLUILEVEL_NONE)
3097 {
3098 WCHAR *deformated;
3099 message = MSI_RecordGetString(row, 2);
3100 deformat_string(package, message, &deformated);
3101 MessageBoxW(NULL, deformated, L"Install Failed", MB_OK);
3102 msi_free(deformated);
3103 }
3104
3105 return ERROR_INSTALL_FAILURE;
3106 }
3107
3108 return ERROR_SUCCESS;
3109 }
3110
3111 static UINT ACTION_LaunchConditions(MSIPACKAGE *package)
3112 {
3113 MSIQUERY *view;
3114 UINT rc;
3115
3116 TRACE("Checking launch conditions\n");
3117
3118 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `LaunchCondition`", &view);
3119 if (rc != ERROR_SUCCESS)
3120 return ERROR_SUCCESS;
3121
3122 rc = MSI_IterateRecords(view, NULL, ITERATE_LaunchConditions, package);
3123 msiobj_release(&view->hdr);
3124 return rc;
3125 }
3126
3127 static LPWSTR resolve_keypath( MSIPACKAGE* package, MSICOMPONENT *cmp )
3128 {
3129
3130 if (!cmp->KeyPath)
3131 return strdupW( msi_get_target_folder( package, cmp->Directory ) );
3132
3133 if (cmp->Attributes & msidbComponentAttributesRegistryKeyPath)
3134 {
3135 MSIRECORD *row;
3136 UINT root, len;
3137 LPWSTR deformated, buffer, deformated_name;
3138 LPCWSTR key, name;
3139
3140 row = MSI_QueryGetRecord(package->db, L"SELECT * FROM `Registry` WHERE `Registry` = '%s'", cmp->KeyPath);
3141 if (!row)
3142 return NULL;
3143
3144 root = MSI_RecordGetInteger(row,2);
3145 key = MSI_RecordGetString(row, 3);
3146 name = MSI_RecordGetString(row, 4);
3147 deformat_string(package, key , &deformated);
3148 deformat_string(package, name, &deformated_name);
3149
3150 len = lstrlenW(deformated) + 6;
3151 if (deformated_name)
3152 len+=lstrlenW(deformated_name);
3153
3154 buffer = msi_alloc( len *sizeof(WCHAR));
3155
3156 if (deformated_name)
3157 swprintf(buffer, len, L"%02d:\\%s\\%s", root, deformated, deformated_name);
3158 else
3159 swprintf(buffer, len, L"%02d:\\%s\\", root, deformated);
3160
3161 msi_free(deformated);
3162 msi_free(deformated_name);
3163 msiobj_release(&row->hdr);
3164
3165 return buffer;
3166 }
3167 else if (cmp->Attributes & msidbComponentAttributesODBCDataSource)
3168 {
3169 FIXME("UNIMPLEMENTED keypath as ODBC Source\n");
3170 return NULL;
3171 }
3172 else
3173 {
3174 MSIFILE *file = msi_get_loaded_file( package, cmp->KeyPath );
3175
3176 if (file)
3177 return strdupW( file->TargetPath );
3178 }
3179 return NULL;
3180 }
3181
3182 static HKEY open_shared_dlls_key( MSICOMPONENT *comp, BOOL create, REGSAM access )
3183 {
3184 return open_key( comp, HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\SharedDLLs",
3185 create, access );
3186 }
3187
3188 static UINT get_shared_dlls_count( MSICOMPONENT *comp )
3189 {
3190 DWORD count, type, sz = sizeof(count);
3191 HKEY hkey = open_shared_dlls_key( comp, FALSE, KEY_READ );
3192 if (RegQueryValueExW( hkey, comp->FullKeypath, NULL, &type, (BYTE *)&count, &sz )) count = 0;
3193 RegCloseKey( hkey );
3194 return count;
3195 }
3196
3197 static void write_shared_dlls_count( MSICOMPONENT *comp, const WCHAR *path, INT count )
3198 {
3199 HKEY hkey = open_shared_dlls_key( comp, TRUE, KEY_SET_VALUE );
3200 if (count > 0)
3201 msi_reg_set_val_dword( hkey, path, count );
3202 else
3203 RegDeleteValueW( hkey, path );
3204 RegCloseKey(hkey);
3205 }
3206
3207 static void refcount_component( MSIPACKAGE *package, MSICOMPONENT *comp )
3208 {
3209 MSIFEATURE *feature;
3210 INT count = 0;
3211 BOOL write = FALSE;
3212
3213 /* only refcount DLLs */
3214 if (!comp->KeyPath || comp->assembly || comp->Attributes & msidbComponentAttributesRegistryKeyPath ||
3215 comp->Attributes & msidbComponentAttributesODBCDataSource)
3216 write = FALSE;
3217 else
3218 {
3219 count = get_shared_dlls_count( comp );
3220 write = (count > 0);
3221 if (comp->Attributes & msidbComponentAttributesSharedDllRefCount)
3222 write = TRUE;
3223 }
3224
3225 /* increment counts */
3226 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3227 {
3228 ComponentList *cl;
3229
3230 if (msi_get_feature_action( package, feature ) != INSTALLSTATE_LOCAL)
3231 continue;
3232
3233 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3234 {
3235 if ( cl->component == comp )
3236 count++;
3237 }
3238 }
3239
3240 /* decrement counts */
3241 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
3242 {
3243 ComponentList *cl;
3244
3245 if (msi_get_feature_action( package, feature ) != INSTALLSTATE_ABSENT)
3246 continue;
3247
3248 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
3249 {
3250 if ( cl->component == comp )
3251 count--;
3252 }
3253 }
3254
3255 /* ref count all the files in the component */
3256 if (write)
3257 {
3258 MSIFILE *file;
3259
3260 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
3261 {
3262 if (file->Component == comp)
3263 write_shared_dlls_count( comp, file->TargetPath, count );
3264 }
3265 }
3266
3267 /* add a count for permanent */
3268 if (comp->Attributes & msidbComponentAttributesPermanent)
3269 count ++;
3270
3271 comp->RefCount = count;
3272
3273 if (write)
3274 write_shared_dlls_count( comp, comp->FullKeypath, comp->RefCount );
3275 }
3276
3277 static WCHAR *build_full_keypath( MSIPACKAGE *package, MSICOMPONENT *comp )
3278 {
3279 if (comp->assembly)
3280 {
3281 DWORD len = lstrlenW( L"<\\" ) + lstrlenW( comp->assembly->display_name );
3282 WCHAR *keypath = msi_alloc( (len + 1) * sizeof(WCHAR) );
3283
3284 if (keypath)
3285 {
3286 lstrcpyW( keypath, L"<\\" );
3287 lstrcatW( keypath, comp->assembly->display_name );
3288 }
3289 return keypath;
3290 }
3291 return resolve_keypath( package, comp );
3292 }
3293
3294 static UINT ACTION_ProcessComponents(MSIPACKAGE *package)
3295 {
3296 WCHAR squashed_pc[SQUASHED_GUID_SIZE], squashed_cc[SQUASHED_GUID_SIZE];
3297 UINT rc;
3298 MSICOMPONENT *comp;
3299 HKEY hkey;
3300
3301 TRACE("\n");
3302
3303 msi_set_sourcedir_props(package, FALSE);
3304
3305 if (package->script == SCRIPT_NONE)
3306 return msi_schedule_action(package, SCRIPT_INSTALL, L"ProcessComponents");
3307
3308 squash_guid( package->ProductCode, squashed_pc );
3309
3310 LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
3311 {
3312 MSIRECORD *uirow;
3313 INSTALLSTATE action;
3314
3315 msi_ui_progress( package, 2, COMPONENT_PROGRESS_VALUE, 0, 0 );
3316 if (!comp->ComponentId)
3317 continue;
3318
3319 squash_guid( comp->ComponentId, squashed_cc );
3320 msi_free( comp->FullKeypath );
3321 comp->FullKeypath = build_full_keypath( package, comp );
3322
3323 refcount_component( package, comp );
3324
3325 if (package->need_rollback) action = comp->Installed;
3326 else action = comp->ActionRequest;
3327
3328 TRACE("Component %s (%s) Keypath=%s RefCount=%u Clients=%u Action=%u\n",
3329 debugstr_w(comp->Component), debugstr_w(squashed_cc),
3330 debugstr_w(comp->FullKeypath), comp->RefCount, comp->num_clients, action);
3331
3332 if (action == INSTALLSTATE_LOCAL || action == INSTALLSTATE_SOURCE)
3333 {
3334 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3335 rc = MSIREG_OpenUserDataComponentKey(comp->ComponentId, L"S-1-5-18", &hkey, TRUE);
3336 else
3337 rc = MSIREG_OpenUserDataComponentKey(comp->ComponentId, NULL, &hkey, TRUE);
3338
3339 if (rc != ERROR_SUCCESS)
3340 continue;
3341
3342 if (comp->Attributes & msidbComponentAttributesPermanent)
3343 {
3344 msi_reg_set_val_str(hkey, L"00000000000000000000000000000000", comp->FullKeypath);
3345 }
3346 if (action == INSTALLSTATE_LOCAL)
3347 msi_reg_set_val_str( hkey, squashed_pc, comp->FullKeypath );
3348 else
3349 {
3350 MSIFILE *file;
3351 MSIRECORD *row;
3352 LPWSTR ptr, ptr2;
3353 WCHAR source[MAX_PATH];
3354 WCHAR base[MAX_PATH];
3355 LPWSTR sourcepath;
3356
3357 if (!comp->KeyPath || !(file = msi_get_loaded_file(package, comp->KeyPath)))
3358 continue;
3359
3360 if (!(row = MSI_QueryGetRecord(package->db, L"SELECT * FROM `Media` WHERE `LastSequence` >= %d "
3361 "ORDER BY `DiskId`", file->Sequence)))
3362 return ERROR_FUNCTION_FAILED;
3363
3364 swprintf(source, ARRAY_SIZE(source), L"%02d\\", MSI_RecordGetInteger(row, 1));
3365 ptr2 = wcsrchr(source, '\\') + 1;
3366 msiobj_release(&row->hdr);
3367
3368 lstrcpyW(base, package->PackagePath);
3369 ptr = wcsrchr(base, '\\');
3370 *(ptr + 1) = '\0';
3371
3372 sourcepath = msi_resolve_file_source(package, file);
3373 ptr = sourcepath + lstrlenW(base);
3374 lstrcpyW(ptr2, ptr);
3375 msi_free(sourcepath);
3376
3377 msi_reg_set_val_str( hkey, squashed_pc, source );
3378 }
3379 RegCloseKey(hkey);
3380 }
3381 else if (action == INSTALLSTATE_ABSENT)
3382 {
3383 if (comp->num_clients <= 0)
3384 {
3385 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3386 rc = MSIREG_DeleteUserDataComponentKey( comp->ComponentId, L"S-1-5-18" );
3387 else
3388 rc = MSIREG_DeleteUserDataComponentKey( comp->ComponentId, NULL );
3389
3390 if (rc != ERROR_SUCCESS) WARN( "failed to delete component key %u\n", rc );
3391 }
3392 else
3393 {
3394 LONG res;
3395
3396 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3397 rc = MSIREG_OpenUserDataComponentKey( comp->ComponentId, L"S-1-5-18", &hkey, FALSE );
3398 else
3399 rc = MSIREG_OpenUserDataComponentKey( comp->ComponentId, NULL, &hkey, FALSE );
3400
3401 if (rc != ERROR_SUCCESS)
3402 {
3403 WARN( "failed to open component key %u\n", rc );
3404 continue;
3405 }
3406 res = RegDeleteValueW( hkey, squashed_pc );
3407 RegCloseKey(hkey);
3408 if (res) WARN( "failed to delete component value %d\n", res );
3409 }
3410 }
3411
3412 /* UI stuff */
3413 uirow = MSI_CreateRecord(3);
3414 MSI_RecordSetStringW(uirow,1,package->ProductCode);
3415 MSI_RecordSetStringW(uirow,2,comp->ComponentId);
3416 MSI_RecordSetStringW(uirow,3,comp->FullKeypath);
3417 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
3418 msiobj_release( &uirow->hdr );
3419 }
3420 return ERROR_SUCCESS;
3421 }
3422
3423 typedef struct {
3424 CLSID clsid;
3425 LPWSTR source;
3426
3427 LPWSTR path;
3428 ITypeLib *ptLib;
3429 } typelib_struct;
3430
3431 static BOOL CALLBACK Typelib_EnumResNameProc( HMODULE hModule, LPCWSTR lpszType,
3432 LPWSTR lpszName, LONG_PTR lParam)
3433 {
3434 TLIBATTR *attr;
3435 typelib_struct *tl_struct = (typelib_struct*) lParam;
3436 int sz;
3437 HRESULT res;
3438
3439 if (!IS_INTRESOURCE(lpszName))
3440 {
3441 ERR("Not Int Resource Name %s\n",debugstr_w(lpszName));
3442 return TRUE;
3443 }
3444
3445 sz = lstrlenW(tl_struct->source)+4;
3446
3447 if ((INT_PTR)lpszName == 1)
3448 tl_struct->path = strdupW(tl_struct->source);
3449 else
3450 {
3451 tl_struct->path = msi_alloc(sz * sizeof(WCHAR));
3452 swprintf(tl_struct->path, sz, L"%s\\%d", tl_struct->source, lpszName);
3453 }
3454
3455 TRACE("trying %s\n", debugstr_w(tl_struct->path));
3456 res = LoadTypeLib(tl_struct->path,&tl_struct->ptLib);
3457 if (FAILED(res))
3458 {
3459 msi_free(tl_struct->path);
3460 tl_struct->path = NULL;
3461
3462 return TRUE;
3463 }
3464
3465 ITypeLib_GetLibAttr(tl_struct->ptLib, &attr);
3466 if (IsEqualGUID(&(tl_struct->clsid),&(attr->guid)))
3467 {
3468 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
3469 return FALSE;
3470 }
3471
3472 msi_free(tl_struct->path);
3473 tl_struct->path = NULL;
3474
3475 ITypeLib_ReleaseTLibAttr(tl_struct->ptLib, attr);
3476 ITypeLib_Release(tl_struct->ptLib);
3477
3478 return TRUE;
3479 }
3480
3481 static HMODULE msi_load_library( MSIPACKAGE *package, const WCHAR *filename, DWORD flags )
3482 {
3483 HMODULE module;
3484 msi_disable_fs_redirection( package );
3485 module = LoadLibraryExW( filename, NULL, flags );
3486 msi_revert_fs_redirection( package );
3487 return module;
3488 }
3489
3490 static HRESULT msi_load_typelib( MSIPACKAGE *package, const WCHAR *filename, REGKIND kind, ITypeLib **lib )
3491 {
3492 HRESULT hr;
3493 msi_disable_fs_redirection( package );
3494 hr = LoadTypeLibEx( filename, kind, lib );
3495 msi_revert_fs_redirection( package );
3496 return hr;
3497 }
3498
3499 static UINT ITERATE_RegisterTypeLibraries(MSIRECORD *row, LPVOID param)
3500 {
3501 MSIPACKAGE* package = param;
3502 LPCWSTR component;
3503 MSICOMPONENT *comp;
3504 MSIFILE *file;
3505 typelib_struct tl_struct;
3506 ITypeLib *tlib;
3507 HMODULE module;
3508 HRESULT hr;
3509
3510 component = MSI_RecordGetString(row,3);
3511 comp = msi_get_loaded_component(package,component);
3512 if (!comp)
3513 return ERROR_SUCCESS;
3514
3515 comp->Action = msi_get_component_action( package, comp );
3516 if (comp->Action != INSTALLSTATE_LOCAL)
3517 {
3518 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
3519 return ERROR_SUCCESS;
3520 }
3521
3522 if (!comp->KeyPath || !(file = msi_get_loaded_file( package, comp->KeyPath )))
3523 {
3524 TRACE("component has no key path\n");
3525 return ERROR_SUCCESS;
3526 }
3527 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, row);
3528
3529 module = msi_load_library( package, file->TargetPath, LOAD_LIBRARY_AS_DATAFILE );
3530 if (module)
3531 {
3532 LPCWSTR guid;
3533 guid = MSI_RecordGetString(row,1);
3534 CLSIDFromString( guid, &tl_struct.clsid);
3535 tl_struct.source = strdupW( file->TargetPath );
3536 tl_struct.path = NULL;
3537
3538 EnumResourceNamesW(module, L"TYPELIB", Typelib_EnumResNameProc,
3539 (LONG_PTR)&tl_struct);
3540
3541 if (tl_struct.path)
3542 {
3543 LPCWSTR helpid, help_path = NULL;
3544 HRESULT res;
3545
3546 helpid = MSI_RecordGetString(row,6);
3547
3548 if (helpid) help_path = msi_get_target_folder( package, helpid );
3549 res = RegisterTypeLib( tl_struct.ptLib, tl_struct.path, (OLECHAR *)help_path );
3550
3551 if (FAILED(res))
3552 ERR("Failed to register type library %s\n", debugstr_w(tl_struct.path));
3553 else
3554 TRACE("Registered %s\n", debugstr_w(tl_struct.path));
3555
3556 ITypeLib_Release(tl_struct.ptLib);
3557 msi_free(tl_struct.path);
3558 }
3559 else ERR("Failed to load type library %s\n", debugstr_w(tl_struct.source));
3560
3561 FreeLibrary(module);
3562 msi_free(tl_struct.source);
3563 }
3564 else
3565 {
3566 hr = msi_load_typelib( package, file->TargetPath, REGKIND_REGISTER, &tlib );
3567 if (FAILED(hr))
3568 {
3569 ERR("Failed to load type library: %08x\n", hr);
3570 return ERROR_INSTALL_FAILURE;
3571 }
3572
3573 ITypeLib_Release(tlib);
3574 }
3575
3576 return ERROR_SUCCESS;
3577 }
3578
3579 static UINT ACTION_RegisterTypeLibraries(MSIPACKAGE *package)
3580 {
3581 MSIQUERY *view;
3582 UINT rc;
3583
3584 if (package->script == SCRIPT_NONE)
3585 return msi_schedule_action(package, SCRIPT_INSTALL, L"RegisterTypeLibraries");
3586
3587 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `TypeLib`", &view);
3588 if (rc != ERROR_SUCCESS)
3589 return ERROR_SUCCESS;
3590
3591 rc = MSI_IterateRecords(view, NULL, ITERATE_RegisterTypeLibraries, package);
3592 msiobj_release(&view->hdr);
3593 return rc;
3594 }
3595
3596 static UINT ITERATE_UnregisterTypeLibraries( MSIRECORD *row, LPVOID param )
3597 {
3598 MSIPACKAGE *package = param;
3599 LPCWSTR component, guid;
3600 MSICOMPONENT *comp;
3601 GUID libid;
3602 UINT version;
3603 LCID language;
3604 SYSKIND syskind;
3605 HRESULT hr;
3606
3607 component = MSI_RecordGetString( row, 3 );
3608 comp = msi_get_loaded_component( package, component );
3609 if (!comp)
3610 return ERROR_SUCCESS;
3611
3612 comp->Action = msi_get_component_action( package, comp );
3613 if (comp->Action != INSTALLSTATE_ABSENT)
3614 {
3615 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
3616 return ERROR_SUCCESS;
3617 }
3618 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, row);
3619
3620 guid = MSI_RecordGetString( row, 1 );
3621 CLSIDFromString( guid, &libid );
3622 version = MSI_RecordGetInteger( row, 4 );
3623 language = MSI_RecordGetInteger( row, 2 );
3624
3625 #ifdef _WIN64
3626 syskind = SYS_WIN64;
3627 #else
3628 syskind = SYS_WIN32;
3629 #endif
3630
3631 hr = UnRegisterTypeLib( &libid, (version >> 8) & 0xffff, version & 0xff, language, syskind );
3632 if (FAILED(hr))
3633 {
3634 WARN("Failed to unregister typelib: %08x\n", hr);
3635 }
3636
3637 return ERROR_SUCCESS;
3638 }
3639
3640 static UINT ACTION_UnregisterTypeLibraries( MSIPACKAGE *package )
3641 {
3642 MSIQUERY *view;
3643 UINT rc;
3644
3645 if (package->script == SCRIPT_NONE)
3646 return msi_schedule_action(package, SCRIPT_INSTALL, L"UnregisterTypeLibraries");
3647
3648 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `TypeLib`", &view );
3649 if (rc != ERROR_SUCCESS)
3650 return ERROR_SUCCESS;
3651
3652 rc = MSI_IterateRecords( view, NULL, ITERATE_UnregisterTypeLibraries, package );
3653 msiobj_release( &view->hdr );
3654 return rc;
3655 }
3656
3657 static WCHAR *get_link_file( MSIPACKAGE *package, MSIRECORD *row )
3658 {
3659 LPCWSTR directory, extension, link_folder;
3660 LPWSTR link_file, filename;
3661
3662 directory = MSI_RecordGetString( row, 2 );
3663 link_folder = msi_get_target_folder( package, directory );
3664 if (!link_folder)
3665 {
3666 ERR("unable to resolve folder %s\n", debugstr_w(directory));
3667 return NULL;
3668 }
3669 /* may be needed because of a bug somewhere else */
3670 msi_create_full_path( package, link_folder );
3671
3672 filename = msi_dup_record_field( row, 3 );
3673 msi_reduce_to_long_filename( filename );
3674
3675 extension = wcsrchr( filename, '.' );
3676 if (!extension || wcsicmp( extension, L".lnk" ))
3677 {
3678 int len = lstrlenW( filename );
3679 filename = msi_realloc( filename, len * sizeof(WCHAR) + sizeof(L".lnk") );
3680 memcpy( filename + len, L".lnk", sizeof(L".lnk") );
3681 }
3682 link_file = msi_build_directory_name( 2, link_folder, filename );
3683 msi_free( filename );
3684
3685 return link_file;
3686 }
3687
3688 WCHAR *msi_build_icon_path( MSIPACKAGE *package, const WCHAR *icon_name )
3689 {
3690 WCHAR *folder, *dest, *path;
3691
3692 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
3693 folder = msi_dup_property( package->db, L"WindowsFolder" );
3694 else
3695 {
3696 WCHAR *appdata = msi_dup_property( package->db, L"AppDataFolder" );
3697 folder = msi_build_directory_name( 2, appdata, L"Microsoft\\" );
3698 msi_free( appdata );
3699 }
3700 dest = msi_build_directory_name( 3, folder, L"Installer\\", package->ProductCode );
3701 msi_create_full_path( package, dest );
3702 path = msi_build_directory_name( 2, dest, icon_name );
3703 msi_free( folder );
3704 msi_free( dest );
3705 return path;
3706 }
3707
3708 static UINT ITERATE_CreateShortcuts(MSIRECORD *row, LPVOID param)
3709 {
3710 MSIPACKAGE *package = param;
3711 LPWSTR link_file, deformated, path;
3712 LPCWSTR component, target;
3713 MSICOMPONENT *comp;
3714 IShellLinkW *sl = NULL;
3715 IPersistFile *pf = NULL;
3716 HRESULT res;
3717
3718 component = MSI_RecordGetString(row, 4);
3719 comp = msi_get_loaded_component(package, component);
3720 if (!comp)
3721 return ERROR_SUCCESS;
3722
3723 comp->Action = msi_get_component_action( package, comp );
3724 if (comp->Action != INSTALLSTATE_LOCAL)
3725 {
3726 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
3727 return ERROR_SUCCESS;
3728 }
3729 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, row);
3730
3731 res = CoCreateInstance( &CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
3732 &IID_IShellLinkW, (LPVOID *) &sl );
3733
3734 if (FAILED( res ))
3735 {
3736 ERR("CLSID_ShellLink not available\n");
3737 goto err;
3738 }
3739
3740 res = IShellLinkW_QueryInterface( sl, &IID_IPersistFile,(LPVOID*) &pf );
3741 if (FAILED( res ))
3742 {
3743 ERR("QueryInterface(IID_IPersistFile) failed\n");
3744 goto err;
3745 }
3746
3747 target = MSI_RecordGetString(row, 5);
3748 if (wcschr(target, '['))
3749 {
3750 deformat_string( package, target, &path );
3751 TRACE("target path is %s\n", debugstr_w(path));
3752 IShellLinkW_SetPath( sl, path );
3753 msi_free( path );
3754 }
3755 else
3756 {
3757 FIXME("poorly handled shortcut format, advertised shortcut\n");
3758 path = resolve_keypath( package, comp );
3759 IShellLinkW_SetPath( sl, path );
3760 msi_free( path );
3761 }
3762
3763 if (!MSI_RecordIsNull(row,6))
3764 {
3765 LPCWSTR arguments = MSI_RecordGetString(row, 6);
3766 deformat_string(package, arguments, &deformated);
3767 IShellLinkW_SetArguments(sl,deformated);
3768 msi_free(deformated);
3769 }
3770
3771 if (!MSI_RecordIsNull(row,7))
3772 {
3773 LPCWSTR description = MSI_RecordGetString(row, 7);
3774 IShellLinkW_SetDescription(sl, description);
3775 }
3776
3777 if (!MSI_RecordIsNull(row,8))
3778 IShellLinkW_SetHotkey(sl,MSI_RecordGetInteger(row,8));
3779
3780 if (!MSI_RecordIsNull(row,9))
3781 {
3782 INT index;
3783 LPCWSTR icon = MSI_RecordGetString(row, 9);
3784
3785 path = msi_build_icon_path(package, icon);
3786 index = MSI_RecordGetInteger(row,10);
3787
3788 /* no value means 0 */
3789 if (index == MSI_NULL_INTEGER)
3790 index = 0;
3791
3792 IShellLinkW_SetIconLocation(sl, path, index);
3793 msi_free(path);
3794 }
3795
3796 if (!MSI_RecordIsNull(row,11))
3797 IShellLinkW_SetShowCmd(sl,MSI_RecordGetInteger(row,11));
3798
3799 if (!MSI_RecordIsNull(row,12))
3800 {
3801 LPCWSTR full_path, wkdir = MSI_RecordGetString( row, 12 );
3802 full_path = msi_get_target_folder( package, wkdir );
3803 if (full_path) IShellLinkW_SetWorkingDirectory( sl, full_path );
3804 }
3805
3806 link_file = get_link_file(package, row);
3807 TRACE("Writing shortcut to %s\n", debugstr_w(link_file));
3808
3809 msi_disable_fs_redirection( package );
3810 IPersistFile_Save(pf, link_file, FALSE);
3811 msi_revert_fs_redirection( package );
3812
3813 msi_free(link_file);
3814
3815 err:
3816 if (pf)
3817 IPersistFile_Release( pf );
3818 if (sl)
3819 IShellLinkW_Release( sl );
3820
3821 return ERROR_SUCCESS;
3822 }
3823
3824 static UINT ACTION_CreateShortcuts(MSIPACKAGE *package)
3825 {
3826 MSIQUERY *view;
3827 HRESULT res;
3828 UINT rc;
3829
3830 if (package->script == SCRIPT_NONE)
3831 return msi_schedule_action(package, SCRIPT_INSTALL, L"CreateShortcuts");
3832
3833 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `Shortcut`", &view);
3834 if (rc != ERROR_SUCCESS)
3835 return ERROR_SUCCESS;
3836
3837 res = CoInitialize( NULL );
3838
3839 rc = MSI_IterateRecords(view, NULL, ITERATE_CreateShortcuts, package);
3840 msiobj_release(&view->hdr);
3841
3842 if (SUCCEEDED(res)) CoUninitialize();
3843 return rc;
3844 }
3845
3846 static UINT ITERATE_RemoveShortcuts( MSIRECORD *row, LPVOID param )
3847 {
3848 MSIPACKAGE *package = param;
3849 LPWSTR link_file;
3850 LPCWSTR component;
3851 MSICOMPONENT *comp;
3852
3853 component = MSI_RecordGetString( row, 4 );
3854 comp = msi_get_loaded_component( package, component );
3855 if (!comp)
3856 return ERROR_SUCCESS;
3857
3858 comp->Action = msi_get_component_action( package, comp );
3859 if (comp->Action != INSTALLSTATE_ABSENT)
3860 {
3861 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
3862 return ERROR_SUCCESS;
3863 }
3864 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, row);
3865
3866 link_file = get_link_file( package, row );
3867 TRACE("Removing shortcut file %s\n", debugstr_w( link_file ));
3868 if (!msi_delete_file( package, link_file )) WARN("Failed to remove shortcut file %u\n", GetLastError());
3869 msi_free( link_file );
3870
3871 return ERROR_SUCCESS;
3872 }
3873
3874 static UINT ACTION_RemoveShortcuts( MSIPACKAGE *package )
3875 {
3876 MSIQUERY *view;
3877 UINT rc;
3878
3879 if (package->script == SCRIPT_NONE)
3880 return msi_schedule_action(package, SCRIPT_INSTALL, L"RemoveShortcuts");
3881
3882 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Shortcut`", &view );
3883 if (rc != ERROR_SUCCESS)
3884 return ERROR_SUCCESS;
3885
3886 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveShortcuts, package );
3887 msiobj_release( &view->hdr );
3888 return rc;
3889 }
3890
3891 static UINT ITERATE_PublishIcon(MSIRECORD *row, LPVOID param)
3892 {
3893 MSIPACKAGE *package = param;
3894 HANDLE handle;
3895 WCHAR *icon_path;
3896 const WCHAR *filename;
3897 char buffer[1024];
3898 DWORD sz;
3899 UINT rc;
3900
3901 filename = MSI_RecordGetString( row, 1 );
3902 if (!filename)
3903 {
3904 ERR("Unable to get filename\n");
3905 return ERROR_SUCCESS;
3906 }
3907
3908 icon_path = msi_build_icon_path( package, filename );
3909
3910 TRACE("Creating icon file at %s\n", debugstr_w(icon_path));
3911
3912 handle = msi_create_file( package, icon_path, GENERIC_WRITE, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL );
3913 if (handle == INVALID_HANDLE_VALUE)
3914 {
3915 ERR("Unable to create file %s\n", debugstr_w(icon_path));
3916 msi_free( icon_path );
3917 return ERROR_SUCCESS;
3918 }
3919
3920 do
3921 {
3922 DWORD count;
3923 sz = 1024;
3924 rc = MSI_RecordReadStream( row, 2, buffer, &sz );
3925 if (rc != ERROR_SUCCESS)
3926 {
3927 ERR("Failed to get stream\n");
3928 msi_delete_file( package, icon_path );
3929 break;
3930 }
3931 WriteFile( handle, buffer, sz, &count, NULL );
3932 } while (sz == 1024);
3933
3934 msi_free( icon_path );
3935 CloseHandle( handle );
3936
3937 return ERROR_SUCCESS;
3938 }
3939
3940 static UINT msi_publish_icons(MSIPACKAGE *package)
3941 {
3942 MSIQUERY *view;
3943 UINT r;
3944
3945 r = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `Icon`", &view);
3946 if (r == ERROR_SUCCESS)
3947 {
3948 r = MSI_IterateRecords(view, NULL, ITERATE_PublishIcon, package);
3949 msiobj_release(&view->hdr);
3950 if (r != ERROR_SUCCESS)
3951 return r;
3952 }
3953 return ERROR_SUCCESS;
3954 }
3955
3956 static UINT msi_publish_sourcelist(MSIPACKAGE *package, HKEY hkey)
3957 {
3958 UINT r;
3959 HKEY source;
3960 LPWSTR buffer;
3961 MSIMEDIADISK *disk;
3962 MSISOURCELISTINFO *info;
3963
3964 r = RegCreateKeyW(hkey, L"SourceList", &source);
3965 if (r != ERROR_SUCCESS)
3966 return r;
3967
3968 RegCloseKey(source);
3969
3970 buffer = wcsrchr(package->PackagePath, '\\') + 1;
3971 r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3972 package->Context, MSICODE_PRODUCT,
3973 INSTALLPROPERTY_PACKAGENAMEW, buffer);
3974 if (r != ERROR_SUCCESS)
3975 return r;
3976
3977 r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3978 package->Context, MSICODE_PRODUCT,
3979 INSTALLPROPERTY_MEDIAPACKAGEPATHW, L"");
3980 if (r != ERROR_SUCCESS)
3981 return r;
3982
3983 r = MsiSourceListSetInfoW(package->ProductCode, NULL,
3984 package->Context, MSICODE_PRODUCT,
3985 INSTALLPROPERTY_DISKPROMPTW, L"");
3986 if (r != ERROR_SUCCESS)
3987 return r;
3988
3989 LIST_FOR_EACH_ENTRY(info, &package->sourcelist_info, MSISOURCELISTINFO, entry)
3990 {
3991 if (!wcscmp( info->property, INSTALLPROPERTY_LASTUSEDSOURCEW ))
3992 msi_set_last_used_source(package->ProductCode, NULL, info->context,
3993 info->options, info->value);
3994 else
3995 MsiSourceListSetInfoW(package->ProductCode, NULL,
3996 info->context, info->options,
3997 info->property, info->value);
3998 }
3999
4000 LIST_FOR_EACH_ENTRY(disk, &package->sourcelist_media, MSIMEDIADISK, entry)
4001 {
4002 MsiSourceListAddMediaDiskW(package->ProductCode, NULL,
4003 disk->context, disk->options,
4004 disk->disk_id, disk->volume_label, disk->disk_prompt);
4005 }
4006
4007 return ERROR_SUCCESS;
4008 }
4009
4010 static UINT msi_publish_product_properties(MSIPACKAGE *package, HKEY hkey)
4011 {
4012 WCHAR *buffer, *ptr, *guids, packcode[SQUASHED_GUID_SIZE];
4013 DWORD langid;
4014
4015 buffer = msi_dup_property(package->db, INSTALLPROPERTY_PRODUCTNAMEW);
4016 msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTNAMEW, buffer);
4017 msi_free(buffer);
4018
4019 langid = msi_get_property_int(package->db, L"ProductLanguage", 0);
4020 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_LANGUAGEW, langid);
4021
4022 /* FIXME */
4023 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_AUTHORIZED_LUA_APPW, 0);
4024
4025 buffer = msi_dup_property(package->db, L"ARPPRODUCTICON");
4026 if (buffer)
4027 {
4028 LPWSTR path = msi_build_icon_path(package, buffer);
4029 msi_reg_set_val_str(hkey, INSTALLPROPERTY_PRODUCTICONW, path);
4030 msi_free(path);
4031 msi_free(buffer);
4032 }
4033
4034 buffer = msi_dup_property(package->db, L"ProductVersion");
4035 if (buffer)
4036 {
4037 DWORD verdword = msi_version_str_to_dword(buffer);
4038 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONW, verdword);
4039 msi_free(buffer);
4040 }
4041
4042 msi_reg_set_val_dword(hkey, L"Assignment", 0);
4043 msi_reg_set_val_dword(hkey, L"AdvertiseFlags", 0x184);
4044 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_INSTANCETYPEW, 0);
4045 msi_reg_set_val_str(hkey, L"Clients", L":");
4046
4047 if (!(guids = msi_get_package_code(package->db))) return ERROR_OUTOFMEMORY;
4048 if ((ptr = wcschr(guids, ';'))) *ptr = 0;
4049 squash_guid(guids, packcode);
4050 msi_free( guids);
4051 msi_reg_set_val_str(hkey, INSTALLPROPERTY_PACKAGECODEW, packcode);
4052
4053 return ERROR_SUCCESS;
4054 }
4055
4056 static UINT msi_publish_upgrade_code(MSIPACKAGE *package)
4057 {
4058 UINT r;
4059 HKEY hkey;
4060 WCHAR *upgrade, squashed_pc[SQUASHED_GUID_SIZE];
4061
4062 upgrade = msi_dup_property(package->db, L"UpgradeCode");
4063 if (!upgrade)
4064 return ERROR_SUCCESS;
4065
4066 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
4067 r = MSIREG_OpenClassesUpgradeCodesKey(upgrade, &hkey, TRUE);
4068 else
4069 r = MSIREG_OpenUserUpgradeCodesKey(upgrade, &hkey, TRUE);
4070
4071 if (r != ERROR_SUCCESS)
4072 {
4073 WARN("failed to open upgrade code key\n");
4074 msi_free(upgrade);
4075 return ERROR_SUCCESS;
4076 }
4077 squash_guid(package->ProductCode, squashed_pc);
4078 msi_reg_set_val_str(hkey, squashed_pc, NULL);
4079 RegCloseKey(hkey);
4080 msi_free(upgrade);
4081 return ERROR_SUCCESS;
4082 }
4083
4084 static BOOL msi_check_publish(MSIPACKAGE *package)
4085 {
4086 MSIFEATURE *feature;
4087
4088 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4089 {
4090 feature->Action = msi_get_feature_action( package, feature );
4091 if (feature->Action == INSTALLSTATE_LOCAL || feature->Action == INSTALLSTATE_SOURCE)
4092 return TRUE;
4093 }
4094
4095 return FALSE;
4096 }
4097
4098 static BOOL msi_check_unpublish(MSIPACKAGE *package)
4099 {
4100 MSIFEATURE *feature;
4101
4102 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4103 {
4104 feature->Action = msi_get_feature_action( package, feature );
4105 if (feature->Action != INSTALLSTATE_ABSENT)
4106 return FALSE;
4107 }
4108
4109 return TRUE;
4110 }
4111
4112 static UINT msi_publish_patches( MSIPACKAGE *package )
4113 {
4114 WCHAR patch_squashed[GUID_SIZE];
4115 HKEY patches_key = NULL, product_patches_key = NULL, product_key;
4116 LONG res;
4117 MSIPATCHINFO *patch;
4118 UINT r;
4119 WCHAR *p, *all_patches = NULL;
4120 DWORD len = 0;
4121
4122 r = MSIREG_OpenProductKey( package->ProductCode, NULL, package->Context, &product_key, TRUE );
4123 if (r != ERROR_SUCCESS)
4124 return ERROR_FUNCTION_FAILED;
4125
4126 res = RegCreateKeyExW( product_key, L"Patches", 0, NULL, 0, KEY_ALL_ACCESS, NULL, &patches_key, NULL );
4127 if (res != ERROR_SUCCESS)
4128 {
4129 r = ERROR_FUNCTION_FAILED;
4130 goto done;
4131 }
4132
4133 r = MSIREG_OpenUserDataProductPatchesKey( package->ProductCode, package->Context, &product_patches_key, TRUE );
4134 if (r != ERROR_SUCCESS)
4135 goto done;
4136
4137 LIST_FOR_EACH_ENTRY( patch, &package->patches, MSIPATCHINFO, entry )
4138 {
4139 squash_guid( patch->patchcode, patch_squashed );
4140 len += lstrlenW( patch_squashed ) + 1;
4141 }
4142
4143 p = all_patches = msi_alloc( (len + 1) * sizeof(WCHAR) );
4144 if (!all_patches)
4145 goto done;
4146
4147 LIST_FOR_EACH_ENTRY( patch, &package->patches, MSIPATCHINFO, entry )
4148 {
4149 HKEY patch_key;
4150
4151 squash_guid( patch->patchcode, p );
4152 p += lstrlenW( p ) + 1;
4153
4154 res = RegSetValueExW( patches_key, patch_squashed, 0, REG_SZ,
4155 (const BYTE *)patch->transforms,
4156 (lstrlenW(patch->transforms) + 1) * sizeof(WCHAR) );
4157 if (res != ERROR_SUCCESS)
4158 goto done;
4159
4160 r = MSIREG_OpenUserDataPatchKey( patch->patchcode, package->Context, &patch_key, TRUE );
4161 if (r != ERROR_SUCCESS)
4162 goto done;
4163
4164 res = RegSetValueExW( patch_key, L"LocalPackage", 0, REG_SZ, (const BYTE *)patch->localfile,
4165 (lstrlenW( patch->localfile ) + 1) * sizeof(WCHAR) );
4166 RegCloseKey( patch_key );
4167 if (res != ERROR_SUCCESS)
4168 goto done;
4169
4170 if (patch->filename && !CopyFileW( patch->filename, patch->localfile, FALSE ))
4171 {
4172 res = GetLastError();
4173 ERR("Unable to copy patch package %d\n", res);
4174 goto done;
4175 }
4176 res = RegCreateKeyExW( product_patches_key, patch_squashed, 0, NULL, 0, KEY_ALL_ACCESS, NULL, &patch_key, NULL );
4177 if (res != ERROR_SUCCESS)
4178 goto done;
4179
4180 res = RegSetValueExW( patch_key, L"State", 0, REG_DWORD, (const BYTE *)&patch->state,
4181 sizeof(patch->state) );
4182 if (res != ERROR_SUCCESS)
4183 {
4184 RegCloseKey( patch_key );
4185 goto done;
4186 }
4187
4188 res = RegSetValueExW( patch_key, L"Uninstallable", 0, REG_DWORD, (const BYTE *)&patch->uninstallable,
4189 sizeof(patch->uninstallable) );
4190 RegCloseKey( patch_key );
4191 if (res != ERROR_SUCCESS)
4192 goto done;
4193 }
4194
4195 all_patches[len] = 0;
4196 res = RegSetValueExW( patches_key, L"Patches", 0, REG_MULTI_SZ,
4197 (const BYTE *)all_patches, (len + 1) * sizeof(WCHAR) );
4198 if (res != ERROR_SUCCESS)
4199 goto done;
4200
4201 res = RegSetValueExW( product_patches_key, L"AllPatches", 0, REG_MULTI_SZ,
4202 (const BYTE *)all_patches, (len + 1) * sizeof(WCHAR) );
4203 if (res != ERROR_SUCCESS)
4204 r = ERROR_FUNCTION_FAILED;
4205
4206 done:
4207 RegCloseKey( product_patches_key );
4208 RegCloseKey( patches_key );
4209 RegCloseKey( product_key );
4210 msi_free( all_patches );
4211 return r;
4212 }
4213
4214 static UINT ACTION_PublishProduct(MSIPACKAGE *package)
4215 {
4216 UINT rc;
4217 HKEY hukey = NULL, hudkey = NULL;
4218 MSIRECORD *uirow;
4219 BOOL republish = FALSE;
4220
4221 if (package->script == SCRIPT_NONE)
4222 return msi_schedule_action(package, SCRIPT_INSTALL, L"PublishProduct");
4223
4224 if (!list_empty(&package->patches))
4225 {
4226 rc = msi_publish_patches(package);
4227 if (rc != ERROR_SUCCESS)
4228 goto end;
4229 }
4230
4231 rc = MSIREG_OpenProductKey(package->ProductCode, NULL, package->Context,
4232 &hukey, FALSE);
4233 if (rc == ERROR_SUCCESS)
4234 {
4235 WCHAR *package_code;
4236
4237 package_code = msi_reg_get_val_str(hukey, INSTALLPROPERTY_PACKAGECODEW);
4238 if (package_code)
4239 {
4240 WCHAR *guid;
4241
4242 guid = msi_get_package_code(package->db);
4243 if (guid)
4244 {
4245 WCHAR packed[SQUASHED_GUID_SIZE];
4246
4247 squash_guid(guid, packed);
4248 msi_free(guid);
4249 if (!wcscmp(packed, package_code))
4250 {
4251 TRACE("re-publishing product - new package\n");
4252 republish = TRUE;
4253 }
4254 }
4255 msi_free(package_code);
4256 }
4257 }
4258
4259 /* FIXME: also need to publish if the product is in advertise mode */
4260 if (!republish && !msi_check_publish(package))
4261 {
4262 if (hukey)
4263 RegCloseKey(hukey);
4264 return ERROR_SUCCESS;
4265 }
4266
4267 if (!hukey)
4268 {
4269 rc = MSIREG_OpenProductKey(package->ProductCode, NULL, package->Context,
4270 &hukey, TRUE);
4271 if (rc != ERROR_SUCCESS)
4272 goto end;
4273 }
4274
4275 rc = MSIREG_OpenUserDataProductKey(package->ProductCode, package->Context,
4276 NULL, &hudkey, TRUE);
4277 if (rc != ERROR_SUCCESS)
4278 goto end;
4279
4280 rc = msi_publish_upgrade_code(package);
4281 if (rc != ERROR_SUCCESS)
4282 goto end;
4283
4284 rc = msi_publish_product_properties(package, hukey);
4285 if (rc != ERROR_SUCCESS)
4286 goto end;
4287
4288 rc = msi_publish_sourcelist(package, hukey);
4289 if (rc != ERROR_SUCCESS)
4290 goto end;
4291
4292 rc = msi_publish_icons(package);
4293
4294 end:
4295 uirow = MSI_CreateRecord( 1 );
4296 MSI_RecordSetStringW( uirow, 1, package->ProductCode );
4297 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
4298 msiobj_release( &uirow->hdr );
4299
4300 RegCloseKey(hukey);
4301 RegCloseKey(hudkey);
4302 return rc;
4303 }
4304
4305 static WCHAR *get_ini_file_name( MSIPACKAGE *package, MSIRECORD *row )
4306 {
4307 WCHAR *filename, *ptr, *folder, *ret;
4308 const WCHAR *dirprop;
4309
4310 filename = msi_dup_record_field( row, 2 );
4311 if (filename && (ptr = wcschr( filename, '|' )))
4312 ptr++;
4313 else
4314 ptr = filename;
4315
4316 dirprop = MSI_RecordGetString( row, 3 );
4317 if (dirprop)
4318 {
4319 folder = strdupW( msi_get_target_folder( package, dirprop ) );
4320 if (!folder) folder = msi_dup_property( package->db, dirprop );
4321 }
4322 else
4323 folder = msi_dup_property( package->db, L"WindowsFolder" );
4324
4325 if (!folder)
4326 {
4327 ERR("Unable to resolve folder %s\n", debugstr_w(dirprop));
4328 msi_free( filename );
4329 return NULL;
4330 }
4331
4332 ret = msi_build_directory_name( 2, folder, ptr );
4333
4334 msi_free( filename );
4335 msi_free( folder );
4336 return ret;
4337 }
4338
4339 static UINT ITERATE_WriteIniValues(MSIRECORD *row, LPVOID param)
4340 {
4341 MSIPACKAGE *package = param;
4342 LPCWSTR component, section, key, value, identifier;
4343 LPWSTR deformated_section, deformated_key, deformated_value, fullname;
4344 MSIRECORD * uirow;
4345 INT action;
4346 MSICOMPONENT *comp;
4347
4348 component = MSI_RecordGetString(row, 8);
4349 comp = msi_get_loaded_component(package,component);
4350 if (!comp)
4351 return ERROR_SUCCESS;
4352
4353 comp->Action = msi_get_component_action( package, comp );
4354 if (comp->Action != INSTALLSTATE_LOCAL)
4355 {
4356 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
4357 return ERROR_SUCCESS;
4358 }
4359
4360 identifier = MSI_RecordGetString(row,1);
4361 section = MSI_RecordGetString(row,4);
4362 key = MSI_RecordGetString(row,5);
4363 value = MSI_RecordGetString(row,6);
4364 action = MSI_RecordGetInteger(row,7);
4365
4366 deformat_string(package,section,&deformated_section);
4367 deformat_string(package,key,&deformated_key);
4368 deformat_string(package,value,&deformated_value);
4369
4370 fullname = get_ini_file_name(package, row);
4371
4372 if (action == 0)
4373 {
4374 TRACE("Adding value %s to section %s in %s\n",
4375 debugstr_w(deformated_key), debugstr_w(deformated_section),
4376 debugstr_w(fullname));
4377 WritePrivateProfileStringW(deformated_section, deformated_key,
4378 deformated_value, fullname);
4379 }
4380 else if (action == 1)
4381 {
4382 WCHAR returned[10];
4383 GetPrivateProfileStringW(deformated_section, deformated_key, NULL,
4384 returned, 10, fullname);
4385 if (returned[0] == 0)
4386 {
4387 TRACE("Adding value %s to section %s in %s\n",
4388 debugstr_w(deformated_key), debugstr_w(deformated_section),
4389 debugstr_w(fullname));
4390
4391 WritePrivateProfileStringW(deformated_section, deformated_key,
4392 deformated_value, fullname);
4393 }
4394 }
4395 else if (action == 3)
4396 FIXME("Append to existing section not yet implemented\n");
4397
4398 uirow = MSI_CreateRecord(4);
4399 MSI_RecordSetStringW(uirow,1,identifier);
4400 MSI_RecordSetStringW(uirow,2,deformated_section);
4401 MSI_RecordSetStringW(uirow,3,deformated_key);
4402 MSI_RecordSetStringW(uirow,4,deformated_value);
4403 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
4404 msiobj_release( &uirow->hdr );
4405
4406 msi_free(fullname);
4407 msi_free(deformated_key);
4408 msi_free(deformated_value);
4409 msi_free(deformated_section);
4410 return ERROR_SUCCESS;
4411 }
4412
4413 static UINT ACTION_WriteIniValues(MSIPACKAGE *package)
4414 {
4415 MSIQUERY *view;
4416 UINT rc;
4417
4418 if (package->script == SCRIPT_NONE)
4419 return msi_schedule_action(package, SCRIPT_INSTALL, L"WriteIniValues");
4420
4421 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `IniFile`", &view);
4422 if (rc != ERROR_SUCCESS)
4423 return ERROR_SUCCESS;
4424
4425 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteIniValues, package);
4426 msiobj_release(&view->hdr);
4427 return rc;
4428 }
4429
4430 static UINT ITERATE_RemoveIniValuesOnUninstall( MSIRECORD *row, LPVOID param )
4431 {
4432 MSIPACKAGE *package = param;
4433 LPCWSTR component, section, key, value, identifier;
4434 LPWSTR deformated_section, deformated_key, deformated_value, filename;
4435 MSICOMPONENT *comp;
4436 MSIRECORD *uirow;
4437 INT action;
4438
4439 component = MSI_RecordGetString( row, 8 );
4440 comp = msi_get_loaded_component( package, component );
4441 if (!comp)
4442 return ERROR_SUCCESS;
4443
4444 comp->Action = msi_get_component_action( package, comp );
4445 if (comp->Action != INSTALLSTATE_ABSENT)
4446 {
4447 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
4448 return ERROR_SUCCESS;
4449 }
4450
4451 identifier = MSI_RecordGetString( row, 1 );
4452 section = MSI_RecordGetString( row, 4 );
4453 key = MSI_RecordGetString( row, 5 );
4454 value = MSI_RecordGetString( row, 6 );
4455 action = MSI_RecordGetInteger( row, 7 );
4456
4457 deformat_string( package, section, &deformated_section );
4458 deformat_string( package, key, &deformated_key );
4459 deformat_string( package, value, &deformated_value );
4460
4461 if (action == msidbIniFileActionAddLine || action == msidbIniFileActionCreateLine)
4462 {
4463 filename = get_ini_file_name( package, row );
4464
4465 TRACE("Removing key %s from section %s in %s\n",
4466 debugstr_w(deformated_key), debugstr_w(deformated_section), debugstr_w(filename));
4467
4468 if (!WritePrivateProfileStringW( deformated_section, deformated_key, NULL, filename ))
4469 {
4470 WARN("Unable to remove key %u\n", GetLastError());
4471 }
4472 msi_free( filename );
4473 }
4474 else
4475 FIXME("Unsupported action %d\n", action);
4476
4477
4478 uirow = MSI_CreateRecord( 4 );
4479 MSI_RecordSetStringW( uirow, 1, identifier );
4480 MSI_RecordSetStringW( uirow, 2, deformated_section );
4481 MSI_RecordSetStringW( uirow, 3, deformated_key );
4482 MSI_RecordSetStringW( uirow, 4, deformated_value );
4483 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
4484 msiobj_release( &uirow->hdr );
4485
4486 msi_free( deformated_key );
4487 msi_free( deformated_value );
4488 msi_free( deformated_section );
4489 return ERROR_SUCCESS;
4490 }
4491
4492 static UINT ITERATE_RemoveIniValuesOnInstall( MSIRECORD *row, LPVOID param )
4493 {
4494 MSIPACKAGE *package = param;
4495 LPCWSTR component, section, key, value, identifier;
4496 LPWSTR deformated_section, deformated_key, deformated_value, filename;
4497 MSICOMPONENT *comp;
4498 MSIRECORD *uirow;
4499 INT action;
4500
4501 component = MSI_RecordGetString( row, 8 );
4502 comp = msi_get_loaded_component( package, component );
4503 if (!comp)
4504 return ERROR_SUCCESS;
4505
4506 comp->Action = msi_get_component_action( package, comp );
4507 if (comp->Action != INSTALLSTATE_LOCAL)
4508 {
4509 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
4510 return ERROR_SUCCESS;
4511 }
4512
4513 identifier = MSI_RecordGetString( row, 1 );
4514 section = MSI_RecordGetString( row, 4 );
4515 key = MSI_RecordGetString( row, 5 );
4516 value = MSI_RecordGetString( row, 6 );
4517 action = MSI_RecordGetInteger( row, 7 );
4518
4519 deformat_string( package, section, &deformated_section );
4520 deformat_string( package, key, &deformated_key );
4521 deformat_string( package, value, &deformated_value );
4522
4523 if (action == msidbIniFileActionRemoveLine)
4524 {
4525 filename = get_ini_file_name( package, row );
4526
4527 TRACE("Removing key %s from section %s in %s\n",
4528 debugstr_w(deformated_key), debugstr_w(deformated_section), debugstr_w(filename));
4529
4530 if (!WritePrivateProfileStringW( deformated_section, deformated_key, NULL, filename ))
4531 {
4532 WARN("Unable to remove key %u\n", GetLastError());
4533 }
4534 msi_free( filename );
4535 }
4536 else
4537 FIXME("Unsupported action %d\n", action);
4538
4539 uirow = MSI_CreateRecord( 4 );
4540 MSI_RecordSetStringW( uirow, 1, identifier );
4541 MSI_RecordSetStringW( uirow, 2, deformated_section );
4542 MSI_RecordSetStringW( uirow, 3, deformated_key );
4543 MSI_RecordSetStringW( uirow, 4, deformated_value );
4544 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
4545 msiobj_release( &uirow->hdr );
4546
4547 msi_free( deformated_key );
4548 msi_free( deformated_value );
4549 msi_free( deformated_section );
4550 return ERROR_SUCCESS;
4551 }
4552
4553 static UINT ACTION_RemoveIniValues( MSIPACKAGE *package )
4554 {
4555 MSIQUERY *view;
4556 UINT rc;
4557
4558 if (package->script == SCRIPT_NONE)
4559 return msi_schedule_action(package, SCRIPT_INSTALL, L"RemoveIniValues");
4560
4561 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `IniFile`", &view );
4562 if (rc == ERROR_SUCCESS)
4563 {
4564 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveIniValuesOnUninstall, package );
4565 msiobj_release( &view->hdr );
4566 if (rc != ERROR_SUCCESS)
4567 return rc;
4568 }
4569 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `RemoveIniFile`", &view );
4570 if (rc == ERROR_SUCCESS)
4571 {
4572 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveIniValuesOnInstall, package );
4573 msiobj_release( &view->hdr );
4574 if (rc != ERROR_SUCCESS)
4575 return rc;
4576 }
4577 return ERROR_SUCCESS;
4578 }
4579
4580 static void register_dll( const WCHAR *dll, BOOL unregister )
4581 {
4582 static const WCHAR regW[] = L"regsvr32.exe \"%s\"";
4583 static const WCHAR unregW[] = L"regsvr32.exe /u \"%s\"";
4584 PROCESS_INFORMATION pi;
4585 STARTUPINFOW si;
4586 WCHAR *cmd;
4587
4588 if (!(cmd = msi_alloc( lstrlenW(dll) * sizeof(WCHAR) + sizeof(unregW) ))) return;
4589
4590 if (unregister) swprintf( cmd, lstrlenW(dll) + ARRAY_SIZE(unregW), unregW, dll );
4591 else swprintf( cmd, lstrlenW(dll) + ARRAY_SIZE(unregW), regW, dll );
4592
4593 memset( &si, 0, sizeof(STARTUPINFOW) );
4594 if (CreateProcessW( NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi ))
4595 {
4596 CloseHandle( pi.hThread );
4597 msi_dialog_check_messages( pi.hProcess );
4598 CloseHandle( pi.hProcess );
4599 }
4600 msi_free( cmd );
4601 }
4602
4603 static UINT ITERATE_SelfRegModules(MSIRECORD *row, LPVOID param)
4604 {
4605 MSIPACKAGE *package = param;
4606 LPCWSTR filename;
4607 MSIFILE *file;
4608 MSIRECORD *uirow;
4609
4610 filename = MSI_RecordGetString( row, 1 );
4611 file = msi_get_loaded_file( package, filename );
4612 if (!file)
4613 {
4614 WARN("unable to find file %s\n", debugstr_w(filename));
4615 return ERROR_SUCCESS;
4616 }
4617 file->Component->Action = msi_get_component_action( package, file->Component );
4618 if (file->Component->Action != INSTALLSTATE_LOCAL)
4619 {
4620 TRACE("component not scheduled for installation %s\n", debugstr_w(file->Component->Component));
4621 return ERROR_SUCCESS;
4622 }
4623
4624 TRACE("Registering %s\n", debugstr_w( file->TargetPath ));
4625 register_dll( file->TargetPath, FALSE );
4626
4627 uirow = MSI_CreateRecord( 2 );
4628 MSI_RecordSetStringW( uirow, 1, file->File );
4629 MSI_RecordSetStringW( uirow, 2, file->Component->Directory );
4630 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
4631 msiobj_release( &uirow->hdr );
4632
4633 return ERROR_SUCCESS;
4634 }
4635
4636 static UINT ACTION_SelfRegModules(MSIPACKAGE *package)
4637 {
4638 MSIQUERY *view;
4639 UINT rc;
4640
4641 if (package->script == SCRIPT_NONE)
4642 return msi_schedule_action(package, SCRIPT_INSTALL, L"SelfRegModules");
4643
4644 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `SelfReg`", &view);
4645 if (rc != ERROR_SUCCESS)
4646 return ERROR_SUCCESS;
4647
4648 rc = MSI_IterateRecords(view, NULL, ITERATE_SelfRegModules, package);
4649 msiobj_release(&view->hdr);
4650 return rc;
4651 }
4652
4653 static UINT ITERATE_SelfUnregModules( MSIRECORD *row, LPVOID param )
4654 {
4655 MSIPACKAGE *package = param;
4656 LPCWSTR filename;
4657 MSIFILE *file;
4658 MSIRECORD *uirow;
4659
4660 filename = MSI_RecordGetString( row, 1 );
4661 file = msi_get_loaded_file( package, filename );
4662 if (!file)
4663 {
4664 WARN("unable to find file %s\n", debugstr_w(filename));
4665 return ERROR_SUCCESS;
4666 }
4667 file->Component->Action = msi_get_component_action( package, file->Component );
4668 if (file->Component->Action != INSTALLSTATE_ABSENT)
4669 {
4670 TRACE("component not scheduled for removal %s\n", debugstr_w(file->Component->Component));
4671 return ERROR_SUCCESS;
4672 }
4673
4674 TRACE("Unregistering %s\n", debugstr_w( file->TargetPath ));
4675 register_dll( file->TargetPath, TRUE );
4676
4677 uirow = MSI_CreateRecord( 2 );
4678 MSI_RecordSetStringW( uirow, 1, file->File );
4679 MSI_RecordSetStringW( uirow, 2, file->Component->Directory );
4680 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
4681 msiobj_release( &uirow->hdr );
4682
4683 return ERROR_SUCCESS;
4684 }
4685
4686 static UINT ACTION_SelfUnregModules( MSIPACKAGE *package )
4687 {
4688 MSIQUERY *view;
4689 UINT rc;
4690
4691 if (package->script == SCRIPT_NONE)
4692 return msi_schedule_action(package, SCRIPT_INSTALL, L"SelfUnregModules");
4693
4694 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `SelfReg`", &view );
4695 if (rc != ERROR_SUCCESS)
4696 return ERROR_SUCCESS;
4697
4698 rc = MSI_IterateRecords( view, NULL, ITERATE_SelfUnregModules, package );
4699 msiobj_release( &view->hdr );
4700 return rc;
4701 }
4702
4703 static UINT ACTION_PublishFeatures(MSIPACKAGE *package)
4704 {
4705 MSIFEATURE *feature;
4706 UINT rc;
4707 HKEY hkey = NULL, userdata = NULL;
4708
4709 if (package->script == SCRIPT_NONE)
4710 return msi_schedule_action(package, SCRIPT_INSTALL, L"PublishFeatures");
4711
4712 if (!msi_check_publish(package))
4713 return ERROR_SUCCESS;
4714
4715 rc = MSIREG_OpenFeaturesKey(package->ProductCode, NULL, package->Context,
4716 &hkey, TRUE);
4717 if (rc != ERROR_SUCCESS)
4718 goto end;
4719
4720 rc = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, NULL, package->Context,
4721 &userdata, TRUE);
4722 if (rc != ERROR_SUCCESS)
4723 goto end;
4724
4725 /* here the guids are base 85 encoded */
4726 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
4727 {
4728 ComponentList *cl;
4729 LPWSTR data = NULL;
4730 GUID clsid;
4731 INT size;
4732 BOOL absent = FALSE;
4733 MSIRECORD *uirow;
4734
4735 if (feature->Level <= 0) continue;
4736 if (feature->Action == INSTALLSTATE_UNKNOWN &&
4737 feature->Installed != INSTALLSTATE_ABSENT) continue;
4738
4739 if (feature->Action != INSTALLSTATE_LOCAL &&
4740 feature->Action != INSTALLSTATE_SOURCE &&
4741 feature->Action != INSTALLSTATE_ADVERTISED) absent = TRUE;
4742
4743 size = 1;
4744 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
4745 {
4746 size += 21;
4747 }
4748 if (feature->Feature_Parent)
4749 size += lstrlenW( feature->Feature_Parent )+2;
4750
4751 data = msi_alloc(size * sizeof(WCHAR));
4752
4753 data[0] = 0;
4754 LIST_FOR_EACH_ENTRY( cl, &feature->Components, ComponentList, entry )
4755 {
4756 MSICOMPONENT* component = cl->component;
4757 WCHAR buf[21];
4758
4759 buf[0] = 0;
4760 if (component->ComponentId)
4761 {
4762 TRACE("From %s\n",debugstr_w(component->ComponentId));
4763 CLSIDFromString(component->ComponentId, &clsid);
4764 encode_base85_guid(&clsid,buf);
4765 TRACE("to %s\n",debugstr_w(buf));
4766 lstrcatW(data,buf);
4767 }
4768 }
4769
4770 if (feature->Feature_Parent)
4771 {
4772 lstrcatW(data, L"\2");
4773 lstrcatW(data, feature->Feature_Parent);
4774 }
4775
4776 msi_reg_set_val_str( userdata, feature->Feature, data );
4777 msi_free(data);
4778
4779 size = 0;
4780 if (feature->Feature_Parent)
4781 size = lstrlenW(feature->Feature_Parent)*sizeof(WCHAR);
4782 if (!absent)
4783 {
4784 size += sizeof(WCHAR);
4785 RegSetValueExW(hkey, feature->Feature, 0 ,REG_SZ,
4786 (const BYTE*)(feature->Feature_Parent ? feature->Feature_Parent : L""), size);
4787 }
4788 else
4789 {
4790 size += 2*sizeof(WCHAR);
4791 data = msi_alloc(size);
4792 data[0] = 0x6;
4793 data[1] = 0;
4794 if (feature->Feature_Parent)
4795 lstrcpyW( &data[1], feature->Feature_Parent );
4796 RegSetValueExW(hkey,feature->Feature,0,REG_SZ,
4797 (LPBYTE)data,size);
4798 msi_free(data);
4799 }
4800
4801 /* the UI chunk */
4802 uirow = MSI_CreateRecord( 1 );
4803 MSI_RecordSetStringW( uirow, 1, feature->Feature );
4804 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
4805 msiobj_release( &uirow->hdr );
4806 /* FIXME: call msi_ui_progress? */
4807 }
4808
4809 end:
4810 RegCloseKey(hkey);
4811 RegCloseKey(userdata);
4812 return rc;
4813 }
4814
4815 static UINT msi_unpublish_feature(MSIPACKAGE *package, MSIFEATURE *feature)
4816 {
4817 UINT r;
4818 HKEY hkey;
4819 MSIRECORD *uirow;
4820
4821 TRACE("unpublishing feature %s\n", debugstr_w(feature->Feature));
4822
4823 r = MSIREG_OpenFeaturesKey(package->ProductCode, NULL, package->Context,
4824 &hkey, FALSE);
4825 if (r == ERROR_SUCCESS)
4826 {
4827 RegDeleteValueW(hkey, feature->Feature);
4828 RegCloseKey(hkey);
4829 }
4830
4831 r = MSIREG_OpenUserDataFeaturesKey(package->ProductCode, NULL, package->Context,
4832 &hkey, FALSE);
4833 if (r == ERROR_SUCCESS)
4834 {
4835 RegDeleteValueW(hkey, feature->Feature);
4836 RegCloseKey(hkey);
4837 }
4838
4839 uirow = MSI_CreateRecord( 1 );
4840 MSI_RecordSetStringW( uirow, 1, feature->Feature );
4841 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
4842 msiobj_release( &uirow->hdr );
4843
4844 return ERROR_SUCCESS;
4845 }
4846
4847 static UINT ACTION_UnpublishFeatures(MSIPACKAGE *package)
4848 {
4849 MSIFEATURE *feature;
4850
4851 if (package->script == SCRIPT_NONE)
4852 return msi_schedule_action(package, SCRIPT_INSTALL, L"UnpublishFeatures");
4853
4854 if (!msi_check_unpublish(package))
4855 return ERROR_SUCCESS;
4856
4857 LIST_FOR_EACH_ENTRY(feature, &package->features, MSIFEATURE, entry)
4858 {
4859 msi_unpublish_feature(package, feature);
4860 }
4861
4862 return ERROR_SUCCESS;
4863 }
4864
4865 static UINT msi_publish_install_properties(MSIPACKAGE *package, HKEY hkey)
4866 {
4867 static const WCHAR *propval[] =
4868 {
4869 L"ARPAUTHORIZEDCDFPREFIX", L"AuthorizedCDFPrefix",
4870 L"ARPCONTACT", L"Contact",
4871 L"ARPCOMMENTS", L"Comments",
4872 L"ProductName", L"DisplayName",
4873 L"ARPHELPLINK", L"HelpLink",
4874 L"ARPHELPTELEPHONE", L"HelpTelephone",
4875 L"ARPINSTALLLOCATION", L"InstallLocation",
4876 L"SourceDir", L"InstallSource",
4877 L"Manufacturer", L"Publisher",
4878 L"ARPREADME", L"ReadMe",
4879 L"ARPSIZE", L"Size",
4880 L"ARPURLINFOABOUT", L"URLInfoAbout",
4881 L"ARPURLUPDATEINFO", L"URLUpdateInfo",
4882 NULL
4883 };
4884 const WCHAR **p = propval;
4885 SYSTEMTIME systime;
4886 DWORD size, langid;
4887 WCHAR date[9], *val, *buffer;
4888 const WCHAR *prop, *key;
4889
4890 while (*p)
4891 {
4892 prop = *p++;
4893 key = *p++;
4894 val = msi_dup_property(package->db, prop);
4895 msi_reg_set_val_str(hkey, key, val);
4896 msi_free(val);
4897 }
4898
4899 msi_reg_set_val_dword(hkey, L"WindowsInstaller", 1);
4900 if (msi_get_property_int( package->db, L"ARPSYSTEMCOMPONENT", 0 ))
4901 {
4902 msi_reg_set_val_dword( hkey, L"SystemComponent", 1 );
4903 }
4904
4905 if (msi_get_property_int( package->db, L"ARPNOREMOVE", 0 ))
4906 msi_reg_set_val_dword( hkey, L"NoRemove", 1 );
4907 else
4908 {
4909 static const WCHAR fmt_install[] = L"MsiExec.exe /I[ProductCode]";
4910 static const WCHAR fmt_uninstall[] = L"MsiExec.exe /X[ProductCode]";
4911 const WCHAR *fmt = fmt_install;
4912
4913 if (msi_get_property_int( package->db, L"ARPNOREPAIR", 0 ))
4914 msi_reg_set_val_dword( hkey, L"NoRepair", 1 );
4915
4916 if (msi_get_property_int( package->db, L"ARPNOMODIFY", 0 ))
4917 {
4918 msi_reg_set_val_dword( hkey, L"NoModify", 1 );
4919 fmt = fmt_uninstall;
4920 }
4921
4922 size = deformat_string(package, fmt, &buffer) * sizeof(WCHAR);
4923 RegSetValueExW(hkey, L"ModifyPath", 0, REG_EXPAND_SZ, (LPBYTE)buffer, size);
4924 RegSetValueExW(hkey, L"UninstallString", 0, REG_EXPAND_SZ, (LPBYTE)buffer, size);
4925 msi_free(buffer);
4926 }
4927
4928 /* FIXME: Write real Estimated Size when we have it */
4929 msi_reg_set_val_dword(hkey, L"EstimatedSize", 0);
4930
4931 GetLocalTime(&systime);
4932 swprintf(date, ARRAY_SIZE(date), L"%d%02d%02d", systime.wYear, systime.wMonth, systime.wDay);
4933 msi_reg_set_val_str(hkey, INSTALLPROPERTY_INSTALLDATEW, date);
4934
4935 langid = msi_get_property_int(package->db, L"ProductLanguage", 0);
4936 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_LANGUAGEW, langid);
4937
4938 buffer = msi_dup_property(package->db, L"ProductVersion");
4939 msi_reg_set_val_str(hkey, L"DisplayVersion", buffer);
4940 if (buffer)
4941 {
4942 DWORD verdword = msi_version_str_to_dword(buffer);
4943
4944 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONW, verdword);
4945 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONMAJORW, verdword >> 24);
4946 msi_reg_set_val_dword(hkey, INSTALLPROPERTY_VERSIONMINORW, (verdword >> 16) & 0xFF);
4947 msi_free(buffer);
4948 }
4949
4950 return ERROR_SUCCESS;
4951 }
4952
4953 static UINT ACTION_RegisterProduct(MSIPACKAGE *package)
4954 {
4955 WCHAR *upgrade_code, squashed_pc[SQUASHED_GUID_SIZE];
4956 MSIRECORD *uirow;
4957 HKEY hkey, props, upgrade_key;
4958 UINT rc;
4959
4960 if (package->script == SCRIPT_NONE)
4961 return msi_schedule_action(package, SCRIPT_INSTALL, L"RegisterProduct");
4962
4963 /* FIXME: also need to publish if the product is in advertise mode */
4964 if (!msi_get_property_int( package->db, L"ProductToBeRegistered", 0 )
4965 && !msi_check_publish(package))
4966 return ERROR_SUCCESS;
4967
4968 rc = MSIREG_OpenUninstallKey(package->ProductCode, package->platform, &hkey, TRUE);
4969 if (rc != ERROR_SUCCESS)
4970 return rc;
4971
4972 rc = MSIREG_OpenInstallProps(package->ProductCode, package->Context, NULL, &props, TRUE);
4973 if (rc != ERROR_SUCCESS)
4974 goto done;
4975
4976 rc = msi_publish_install_properties(package, hkey);
4977 if (rc != ERROR_SUCCESS)
4978 goto done;
4979
4980 rc = msi_publish_install_properties(package, props);
4981 if (rc != ERROR_SUCCESS)
4982 goto done;
4983
4984 upgrade_code = msi_dup_property(package->db, L"UpgradeCode");
4985 if (upgrade_code)
4986 {
4987 rc = MSIREG_OpenUpgradeCodesKey( upgrade_code, &upgrade_key, TRUE );
4988 if (rc == ERROR_SUCCESS)
4989 {
4990 squash_guid( package->ProductCode, squashed_pc );
4991 msi_reg_set_val_str( upgrade_key, squashed_pc, NULL );
4992 RegCloseKey( upgrade_key );
4993 }
4994 msi_free( upgrade_code );
4995 }
4996 msi_reg_set_val_str( props, INSTALLPROPERTY_LOCALPACKAGEW, package->localfile );
4997 package->delete_on_close = FALSE;
4998
4999 done:
5000 uirow = MSI_CreateRecord( 1 );
5001 MSI_RecordSetStringW( uirow, 1, package->ProductCode );
5002 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
5003 msiobj_release( &uirow->hdr );
5004
5005 RegCloseKey(hkey);
5006 return ERROR_SUCCESS;
5007 }
5008
5009 static UINT ACTION_InstallExecute(MSIPACKAGE *package)
5010 {
5011 return execute_script(package, SCRIPT_INSTALL);
5012 }
5013
5014 static UINT ITERATE_UnpublishIcon( MSIRECORD *row, LPVOID param )
5015 {
5016 MSIPACKAGE *package = param;
5017 const WCHAR *icon = MSI_RecordGetString( row, 1 );
5018 WCHAR *p, *icon_path;
5019
5020 if (!icon) return ERROR_SUCCESS;
5021 if ((icon_path = msi_build_icon_path( package, icon )))
5022 {
5023 TRACE("removing icon file %s\n", debugstr_w(icon_path));
5024 msi_delete_file( package, icon_path );
5025 if ((p = wcsrchr( icon_path, '\\' )))
5026 {
5027 *p = 0;
5028 msi_remove_directory( package, icon_path );
5029 }
5030 msi_free( icon_path );
5031 }
5032 return ERROR_SUCCESS;
5033 }
5034
5035 static UINT msi_unpublish_icons( MSIPACKAGE *package )
5036 {
5037 MSIQUERY *view;
5038 UINT r;
5039
5040 r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Icon`", &view );
5041 if (r == ERROR_SUCCESS)
5042 {
5043 r = MSI_IterateRecords( view, NULL, ITERATE_UnpublishIcon, package );
5044 msiobj_release( &view->hdr );
5045 if (r != ERROR_SUCCESS)
5046 return r;
5047 }
5048 return ERROR_SUCCESS;
5049 }
5050
5051 static void remove_product_upgrade_code( MSIPACKAGE *package )
5052 {
5053 WCHAR *code, product[SQUASHED_GUID_SIZE];
5054 HKEY hkey;
5055 LONG res;
5056 DWORD count;
5057
5058 squash_guid( package->ProductCode, product );
5059 if (!(code = msi_dup_property( package->db, L"UpgradeCode" )))
5060 {
5061 WARN( "upgrade code not found\n" );
5062 return;
5063 }
5064 if (!MSIREG_OpenUpgradeCodesKey( code, &hkey, FALSE ))
5065 {
5066 RegDeleteValueW( hkey, product );
5067 res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, NULL, NULL, &count, NULL, NULL, NULL, NULL, NULL );
5068 RegCloseKey( hkey );
5069 if (!res && !count) MSIREG_DeleteUpgradeCodesKey( code );
5070 }
5071 if (!MSIREG_OpenUserUpgradeCodesKey( code, &hkey, FALSE ))
5072 {
5073 RegDeleteValueW( hkey, product );
5074 res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, NULL, NULL, &count, NULL, NULL, NULL, NULL, NULL );
5075 RegCloseKey( hkey );
5076 if (!res && !count) MSIREG_DeleteUserUpgradeCodesKey( code );
5077 }
5078 if (!MSIREG_OpenClassesUpgradeCodesKey( code, &hkey, FALSE ))
5079 {
5080 RegDeleteValueW( hkey, product );
5081 res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, NULL, NULL, &count, NULL, NULL, NULL, NULL, NULL );
5082 RegCloseKey( hkey );
5083 if (!res && !count) MSIREG_DeleteClassesUpgradeCodesKey( code );
5084 }
5085
5086 msi_free( code );
5087 }
5088
5089 static UINT ACTION_UnpublishProduct(MSIPACKAGE *package)
5090 {
5091 MSIPATCHINFO *patch;
5092
5093 MSIREG_DeleteProductKey(package->ProductCode);
5094 MSIREG_DeleteUserDataProductKey(package->ProductCode, package->Context);
5095 MSIREG_DeleteUninstallKey(package->ProductCode, package->platform);
5096
5097 MSIREG_DeleteLocalClassesProductKey(package->ProductCode);
5098 MSIREG_DeleteLocalClassesFeaturesKey(package->ProductCode);
5099 MSIREG_DeleteUserProductKey(package->ProductCode);
5100 MSIREG_DeleteUserFeaturesKey(package->ProductCode);
5101
5102 remove_product_upgrade_code( package );
5103
5104 LIST_FOR_EACH_ENTRY(patch, &package->patches, MSIPATCHINFO, entry)
5105 {
5106 MSIREG_DeleteUserDataPatchKey(patch->patchcode, package->Context);
5107 if (!wcscmp( package->ProductCode, patch->products ))
5108 {
5109 TRACE("removing local patch package %s\n", debugstr_w(patch->localfile));
5110 patch->delete_on_close = TRUE;
5111 }
5112 /* FIXME: remove local patch package if this is the last product */
5113 }
5114 TRACE("removing local package %s\n", debugstr_w(package->localfile));
5115 package->delete_on_close = TRUE;
5116
5117 msi_unpublish_icons( package );
5118 return ERROR_SUCCESS;
5119 }
5120
5121 static BOOL is_full_uninstall( MSIPACKAGE *package )
5122 {
5123 MSIFEATURE *feature;
5124
5125 LIST_FOR_EACH_ENTRY( feature, &package->features, MSIFEATURE, entry )
5126 {
5127 if (feature->Action != INSTALLSTATE_ABSENT &&
5128 (feature->Installed != INSTALLSTATE_ABSENT || feature->Action != INSTALLSTATE_UNKNOWN))
5129 return FALSE;
5130 }
5131
5132 return TRUE;
5133 }
5134
5135 static UINT ACTION_InstallFinalize(MSIPACKAGE *package)
5136 {
5137 UINT rc;
5138
5139 /* first do the same as an InstallExecute */
5140 rc = execute_script(package, SCRIPT_INSTALL);
5141 if (rc != ERROR_SUCCESS)
5142 return rc;
5143
5144 /* then handle commit actions */
5145 rc = execute_script(package, SCRIPT_COMMIT);
5146 if (rc != ERROR_SUCCESS)
5147 return rc;
5148
5149 if (is_full_uninstall(package))
5150 rc = ACTION_UnpublishProduct(package);
5151
5152 return rc;
5153 }
5154
5155 UINT ACTION_ForceReboot(MSIPACKAGE *package)
5156 {
5157 WCHAR buffer[256], sysdir[MAX_PATH], squashed_pc[SQUASHED_GUID_SIZE];
5158 HKEY hkey;
5159
5160 squash_guid( package->ProductCode, squashed_pc );
5161
5162 GetSystemDirectoryW(sysdir, ARRAY_SIZE(sysdir));
5163 RegCreateKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce", &hkey);
5164 swprintf(buffer, ARRAY_SIZE(buffer), L"%s\\MsiExec.exe /@ \"%s\"", sysdir, squashed_pc);
5165
5166 msi_reg_set_val_str( hkey, squashed_pc, buffer );
5167 RegCloseKey(hkey);
5168
5169 TRACE("Reboot command %s\n",debugstr_w(buffer));
5170
5171 RegCreateKeyW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\RunOnceEntries",
5172 &hkey);
5173 swprintf( buffer, ARRAY_SIZE(buffer), L"/I \"%s\" AFTERREBOOT=1 RUNONCEENTRY=\"%s\"", package->ProductCode,
5174 squashed_pc );
5175
5176 msi_reg_set_val_str( hkey, squashed_pc, buffer );
5177 RegCloseKey(hkey);
5178
5179 return ERROR_INSTALL_SUSPEND;
5180 }
5181
5182 static UINT ACTION_ResolveSource(MSIPACKAGE* package)
5183 {
5184 DWORD attrib;
5185 UINT rc;
5186
5187 /*
5188 * We are currently doing what should be done here in the top level Install
5189 * however for Administrative and uninstalls this step will be needed
5190 */
5191 if (!package->PackagePath)
5192 return ERROR_SUCCESS;
5193
5194 msi_set_sourcedir_props(package, TRUE);
5195
5196 attrib = GetFileAttributesW(package->db->path);
5197 if (attrib == INVALID_FILE_ATTRIBUTES)
5198 {
5199 MSIRECORD *record;
5200 LPWSTR prompt;
5201 DWORD size = 0;
5202
5203 rc = MsiSourceListGetInfoW(package->ProductCode, NULL,
5204 package->Context, MSICODE_PRODUCT,
5205 INSTALLPROPERTY_DISKPROMPTW,NULL,&size);
5206 if (rc == ERROR_MORE_DATA)
5207 {
5208 prompt = msi_alloc(size * sizeof(WCHAR));
5209 MsiSourceListGetInfoW(package->ProductCode, NULL,
5210 package->Context, MSICODE_PRODUCT,
5211 INSTALLPROPERTY_DISKPROMPTW,prompt,&size);
5212 }
5213 else
5214 prompt = strdupW(package->db->path);
5215
5216 record = MSI_CreateRecord(2);
5217 MSI_RecordSetInteger(record, 1, MSIERR_INSERTDISK);
5218 MSI_RecordSetStringW(record, 2, prompt);
5219 msi_free(prompt);
5220 while(attrib == INVALID_FILE_ATTRIBUTES)
5221 {
5222 MSI_RecordSetStringW(record, 0, NULL);
5223 rc = MSI_ProcessMessage(package, INSTALLMESSAGE_ERROR, record);
5224 if (rc == IDCANCEL)
5225 return ERROR_INSTALL_USEREXIT;
5226 attrib = GetFileAttributesW(package->db->path);
5227 }
5228 rc = ERROR_SUCCESS;
5229 }
5230 else
5231 return ERROR_SUCCESS;
5232
5233 return rc;
5234 }
5235
5236 static UINT ACTION_RegisterUser(MSIPACKAGE *package)
5237 {
5238 static const WCHAR szPropKeys[][80] =
5239 {
5240 L"ProductID",
5241 L"USERNAME",
5242 L"COMPANYNAME",
5243 L"",
5244 };
5245 static const WCHAR szRegKeys[][80] =
5246 {
5247 L"ProductID",
5248 L"RegOwner",
5249 L"RegCompany",
5250 L"",
5251 };
5252 HKEY hkey = 0;
5253 LPWSTR buffer, productid = NULL;
5254 UINT i, rc = ERROR_SUCCESS;
5255 MSIRECORD *uirow;
5256
5257 if (package->script == SCRIPT_NONE)
5258 return msi_schedule_action(package, SCRIPT_INSTALL, L"RegisterUser");
5259
5260 if (msi_check_unpublish(package))
5261 {
5262 MSIREG_DeleteUserDataProductKey(package->ProductCode, package->Context);
5263 goto end;
5264 }
5265
5266 productid = msi_dup_property( package->db, INSTALLPROPERTY_PRODUCTIDW );
5267 if (!productid)
5268 goto end;
5269
5270 rc = MSIREG_OpenInstallProps(package->ProductCode, package->Context,
5271 NULL, &hkey, TRUE);
5272 if (rc != ERROR_SUCCESS)
5273 goto end;
5274
5275 for( i = 0; szPropKeys[i][0]; i++ )
5276 {
5277 buffer = msi_dup_property( package->db, szPropKeys[i] );
5278 msi_reg_set_val_str( hkey, szRegKeys[i], buffer );
5279 msi_free( buffer );
5280 }
5281
5282 end:
5283 uirow = MSI_CreateRecord( 1 );
5284 MSI_RecordSetStringW( uirow, 1, productid );
5285 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
5286 msiobj_release( &uirow->hdr );
5287
5288 msi_free(productid);
5289 RegCloseKey(hkey);
5290 return rc;
5291 }
5292
5293 static UINT iterate_properties(MSIRECORD *record, void *param)
5294 {
5295 MSIRECORD *uirow;
5296
5297 uirow = MSI_CloneRecord(record);
5298 if (!uirow) return ERROR_OUTOFMEMORY;
5299 MSI_RecordSetStringW(uirow, 0, L"Property(S): [1] = [2]");
5300 MSI_ProcessMessage(param, INSTALLMESSAGE_INFO|MB_ICONHAND, uirow);
5301 msiobj_release(&uirow->hdr);
5302
5303 return ERROR_SUCCESS;
5304 }
5305
5306
5307 static UINT ACTION_ExecuteAction(MSIPACKAGE *package)
5308 {
5309 WCHAR *productname;
5310 WCHAR *action;
5311 WCHAR *info_template;
5312 MSIQUERY *view;
5313 MSIRECORD *uirow, *uirow_info;
5314 UINT rc;
5315
5316 /* Send COMMONDATA and INFO messages. */
5317 /* FIXME: when should these messages be sent? [see also MsiOpenPackage()] */
5318 uirow = MSI_CreateRecord(3);
5319 if (!uirow) return ERROR_OUTOFMEMORY;
5320 MSI_RecordSetStringW(uirow, 0, NULL);
5321 MSI_RecordSetInteger(uirow, 1, 0);
5322 MSI_RecordSetInteger(uirow, 2, package->num_langids ? package->langids[0] : 0);
5323 MSI_RecordSetInteger(uirow, 3, msi_get_string_table_codepage(package->db->strings));
5324 MSI_ProcessMessageVerbatim(package, INSTALLMESSAGE_COMMONDATA, uirow);
5325 /* FIXME: send INSTALLMESSAGE_PROGRESS */
5326 MSI_ProcessMessageVerbatim(package, INSTALLMESSAGE_COMMONDATA, uirow);
5327
5328 if (!(needs_ui_sequence(package) && ui_sequence_exists(package)))
5329 {
5330 uirow_info = MSI_CreateRecord(0);
5331 if (!uirow_info)
5332 {
5333 msiobj_release(&uirow->hdr);
5334 return ERROR_OUTOFMEMORY;
5335 }
5336 info_template = msi_get_error_message(package->db, MSIERR_INFO_LOGGINGSTART);
5337 MSI_RecordSetStringW(uirow_info, 0, info_template);
5338 msi_free(info_template);
5339 MSI_ProcessMessage(package, INSTALLMESSAGE_INFO|MB_ICONHAND, uirow_info);
5340 msiobj_release(&uirow_info->hdr);
5341 }
5342
5343 MSI_ProcessMessage(package, INSTALLMESSAGE_COMMONDATA, uirow);
5344
5345 productname = msi_dup_property(package->db, INSTALLPROPERTY_PRODUCTNAMEW);
5346 MSI_RecordSetInteger(uirow, 1, 1);
5347 MSI_RecordSetStringW(uirow, 2, productname);
5348 MSI_RecordSetStringW(uirow, 3, NULL);
5349 MSI_ProcessMessage(package, INSTALLMESSAGE_COMMONDATA, uirow);
5350 msiobj_release(&uirow->hdr);
5351
5352 package->LastActionResult = MSI_NULL_INTEGER;
5353
5354 action = msi_dup_property(package->db, L"EXECUTEACTION");
5355 if (!action) action = msi_strdupW(L"INSTALL", ARRAY_SIZE(L"INSTALL") - 1);
5356
5357 /* Perform the action. Top-level actions trigger a sequence. */
5358 if (!wcscmp(action, L"INSTALL"))
5359 {
5360 /* Send ACTIONSTART/INFO and INSTALLSTART. */
5361 ui_actionstart(package, L"INSTALL", NULL, NULL);
5362 ui_actioninfo(package, L"INSTALL", TRUE, 0);
5363 uirow = MSI_CreateRecord(2);
5364 if (!uirow)
5365 {
5366 rc = ERROR_OUTOFMEMORY;
5367 goto end;
5368 }
5369 MSI_RecordSetStringW(uirow, 0, NULL);
5370 MSI_RecordSetStringW(uirow, 1, productname);
5371 MSI_RecordSetStringW(uirow, 2, package->ProductCode);
5372 MSI_ProcessMessage(package, INSTALLMESSAGE_INSTALLSTART, uirow);
5373 msiobj_release(&uirow->hdr);
5374
5375 /* Perform the installation. Always use the ExecuteSequence. */
5376 package->InWhatSequence |= SEQUENCE_EXEC;
5377 rc = ACTION_ProcessExecSequence(package);
5378
5379 /* Send return value and INSTALLEND. */
5380 ui_actioninfo(package, L"INSTALL", FALSE, !rc);
5381 uirow = MSI_CreateRecord(3);
5382 if (!uirow)
5383 {
5384 rc = ERROR_OUTOFMEMORY;
5385 goto end;
5386 }
5387 MSI_RecordSetStringW(uirow, 0, NULL);
5388 MSI_RecordSetStringW(uirow, 1, productname);
5389 MSI_RecordSetStringW(uirow, 2, package->ProductCode);
5390 MSI_RecordSetInteger(uirow, 3, !rc);
5391 MSI_ProcessMessage(package, INSTALLMESSAGE_INSTALLEND, uirow);
5392 msiobj_release(&uirow->hdr);
5393 }
5394 else
5395 rc = ACTION_PerformAction(package, action);
5396
5397 /* Send all set properties. */
5398 if (!MSI_OpenQuery(package->db, &view, L"SELECT * FROM `_Property`"))
5399 {
5400 MSI_IterateRecords(view, NULL, iterate_properties, package);
5401 msiobj_release(&view->hdr);
5402 }
5403
5404 /* And finally, toggle the cancel off and on. */
5405 uirow = MSI_CreateRecord(2);
5406 if (!uirow)
5407 {
5408 rc = ERROR_OUTOFMEMORY;
5409 goto end;
5410 }
5411 MSI_RecordSetStringW(uirow, 0, NULL);
5412 MSI_RecordSetInteger(uirow, 1, 2);
5413 MSI_RecordSetInteger(uirow, 2, 0);
5414 MSI_ProcessMessageVerbatim(package, INSTALLMESSAGE_COMMONDATA, uirow);
5415 MSI_RecordSetInteger(uirow, 2, 1);
5416 MSI_ProcessMessageVerbatim(package, INSTALLMESSAGE_COMMONDATA, uirow);
5417 msiobj_release(&uirow->hdr);
5418
5419 end:
5420 msi_free(productname);
5421 msi_free(action);
5422 return rc;
5423 }
5424
5425 static UINT ACTION_INSTALL(MSIPACKAGE *package)
5426 {
5427 msi_set_property(package->db, L"EXECUTEACTION", L"INSTALL", -1);
5428 if (needs_ui_sequence(package) && ui_sequence_exists(package))
5429 {
5430 package->InWhatSequence |= SEQUENCE_UI;
5431 return ACTION_ProcessUISequence(package);
5432 }
5433 else
5434 return ACTION_ExecuteAction(package);
5435 }
5436
5437 WCHAR *msi_create_component_advertise_string( MSIPACKAGE *package, MSICOMPONENT *component, const WCHAR *feature )
5438 {
5439 WCHAR productid_85[21], component_85[21], *ret;
5440 GUID clsid;
5441 DWORD sz;
5442
5443 /* > is used if there is a component GUID and < if not. */
5444
5445 productid_85[0] = 0;
5446 component_85[0] = 0;
5447 CLSIDFromString( package->ProductCode, &clsid );
5448
5449 encode_base85_guid( &clsid, productid_85 );
5450 if (component)
5451 {
5452 CLSIDFromString( component->ComponentId, &clsid );
5453 encode_base85_guid( &clsid, component_85 );
5454 }
5455
5456 TRACE("product=%s feature=%s component=%s\n", debugstr_w(productid_85), debugstr_w(feature),
5457 debugstr_w(component_85));
5458
5459 sz = 20 + lstrlenW( feature ) + 20 + 3;
5460 ret = msi_alloc_zero( sz * sizeof(WCHAR) );
5461 if (ret) swprintf( ret, sz, L"%s%s%c%s", productid_85, feature, component ? '>' : '<', component_85 );
5462 return ret;
5463 }
5464
5465 static UINT ITERATE_PublishComponent(MSIRECORD *rec, LPVOID param)
5466 {
5467 MSIPACKAGE *package = param;
5468 LPCWSTR compgroupid, component, feature, qualifier, text;
5469 LPWSTR advertise = NULL, output = NULL, existing = NULL, p, q;
5470 HKEY hkey = NULL;
5471 UINT rc;
5472 MSICOMPONENT *comp;
5473 MSIFEATURE *feat;
5474 DWORD sz;
5475 MSIRECORD *uirow;
5476 int len;
5477
5478 feature = MSI_RecordGetString(rec, 5);
5479 feat = msi_get_loaded_feature(package, feature);
5480 if (!feat)
5481 return ERROR_SUCCESS;
5482
5483 feat->Action = msi_get_feature_action( package, feat );
5484 if (feat->Action != INSTALLSTATE_LOCAL &&
5485 feat->Action != INSTALLSTATE_SOURCE &&
5486 feat->Action != INSTALLSTATE_ADVERTISED)
5487 {
5488 TRACE("feature not scheduled for installation %s\n", debugstr_w(feature));
5489 return ERROR_SUCCESS;
5490 }
5491
5492 component = MSI_RecordGetString(rec, 3);
5493 comp = msi_get_loaded_component(package, component);
5494 if (!comp)
5495 return ERROR_SUCCESS;
5496
5497 compgroupid = MSI_RecordGetString(rec,1);
5498 qualifier = MSI_RecordGetString(rec,2);
5499
5500 rc = MSIREG_OpenUserComponentsKey(compgroupid, &hkey, TRUE);
5501 if (rc != ERROR_SUCCESS)
5502 goto end;
5503
5504 advertise = msi_create_component_advertise_string( package, comp, feature );
5505 text = MSI_RecordGetString( rec, 4 );
5506 if (text)
5507 {
5508 p = msi_alloc( (lstrlenW( advertise ) + lstrlenW( text ) + 1) * sizeof(WCHAR) );
5509 lstrcpyW( p, advertise );
5510 lstrcatW( p, text );
5511 msi_free( advertise );
5512 advertise = p;
5513 }
5514 existing = msi_reg_get_val_str( hkey, qualifier );
5515
5516 sz = lstrlenW( advertise ) + 1;
5517 if (existing)
5518 {
5519 for (p = existing; *p; p += len)
5520 {
5521 len = lstrlenW( p ) + 1;
5522 if (wcscmp( advertise, p )) sz += len;
5523 }
5524 }
5525 if (!(output = msi_alloc( (sz + 1) * sizeof(WCHAR) )))
5526 {
5527 rc = ERROR_OUTOFMEMORY;
5528 goto end;
5529 }
5530 q = output;
5531 if (existing)
5532 {
5533 for (p = existing; *p; p += len)
5534 {
5535 len = lstrlenW( p ) + 1;
5536 if (wcscmp( advertise, p ))
5537 {
5538 memcpy( q, p, len * sizeof(WCHAR) );
5539 q += len;
5540 }
5541 }
5542 }
5543 lstrcpyW( q, advertise );
5544 q[lstrlenW( q ) + 1] = 0;
5545
5546 msi_reg_set_val_multi_str( hkey, qualifier, output );
5547
5548 end:
5549 RegCloseKey(hkey);
5550 msi_free( output );
5551 msi_free( advertise );
5552 msi_free( existing );
5553
5554 /* the UI chunk */
5555 uirow = MSI_CreateRecord( 2 );
5556 MSI_RecordSetStringW( uirow, 1, compgroupid );
5557 MSI_RecordSetStringW( uirow, 2, qualifier);
5558 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
5559 msiobj_release( &uirow->hdr );
5560 /* FIXME: call ui_progress? */
5561
5562 return rc;
5563 }
5564
5565 /*
5566 * At present I am ignoring the advertised components part of this and only
5567 * focusing on the qualified component sets
5568 */
5569 static UINT ACTION_PublishComponents(MSIPACKAGE *package)
5570 {
5571 MSIQUERY *view;
5572 UINT rc;
5573
5574 if (package->script == SCRIPT_NONE)
5575 return msi_schedule_action(package, SCRIPT_INSTALL, L"PublishComponents");
5576
5577 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `PublishComponent`", &view);
5578 if (rc != ERROR_SUCCESS)
5579 return ERROR_SUCCESS;
5580
5581 rc = MSI_IterateRecords(view, NULL, ITERATE_PublishComponent, package);
5582 msiobj_release(&view->hdr);
5583 return rc;
5584 }
5585
5586 static UINT ITERATE_UnpublishComponent( MSIRECORD *rec, LPVOID param )
5587 {
5588 MSIPACKAGE *package = param;
5589 LPCWSTR compgroupid, component, feature, qualifier;
5590 MSICOMPONENT *comp;
5591 MSIFEATURE *feat;
5592 MSIRECORD *uirow;
5593 WCHAR squashed[GUID_SIZE], keypath[MAX_PATH];
5594 LONG res;
5595
5596 feature = MSI_RecordGetString( rec, 5 );
5597 feat = msi_get_loaded_feature( package, feature );
5598 if (!feat)
5599 return ERROR_SUCCESS;
5600
5601 feat->Action = msi_get_feature_action( package, feat );
5602 if (feat->Action != INSTALLSTATE_ABSENT)
5603 {
5604 TRACE("feature not scheduled for removal %s\n", debugstr_w(feature));
5605 return ERROR_SUCCESS;
5606 }
5607
5608 component = MSI_RecordGetString( rec, 3 );
5609 comp = msi_get_loaded_component( package, component );
5610 if (!comp)
5611 return ERROR_SUCCESS;
5612
5613 compgroupid = MSI_RecordGetString( rec, 1 );
5614 qualifier = MSI_RecordGetString( rec, 2 );
5615
5616 squash_guid( compgroupid, squashed );
5617 lstrcpyW( keypath, L"Software\\Microsoft\\Installer\\Components\\" );
5618 lstrcatW( keypath, squashed );
5619
5620 res = RegDeleteKeyW( HKEY_CURRENT_USER, keypath );
5621 if (res != ERROR_SUCCESS)
5622 {
5623 WARN("Unable to delete component key %d\n", res);
5624 }
5625
5626 uirow = MSI_CreateRecord( 2 );
5627 MSI_RecordSetStringW( uirow, 1, compgroupid );
5628 MSI_RecordSetStringW( uirow, 2, qualifier );
5629 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
5630 msiobj_release( &uirow->hdr );
5631
5632 return ERROR_SUCCESS;
5633 }
5634
5635 static UINT ACTION_UnpublishComponents( MSIPACKAGE *package )
5636 {
5637 MSIQUERY *view;
5638 UINT rc;
5639
5640 if (package->script == SCRIPT_NONE)
5641 return msi_schedule_action(package, SCRIPT_INSTALL, L"UnpublishComponents");
5642
5643 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `PublishComponent`", &view );
5644 if (rc != ERROR_SUCCESS)
5645 return ERROR_SUCCESS;
5646
5647 rc = MSI_IterateRecords( view, NULL, ITERATE_UnpublishComponent, package );
5648 msiobj_release( &view->hdr );
5649 return rc;
5650 }
5651
5652 static UINT ITERATE_InstallService(MSIRECORD *rec, LPVOID param)
5653 {
5654 MSIPACKAGE *package = param;
5655 MSICOMPONENT *component;
5656 MSIRECORD *row;
5657 MSIFILE *file;
5658 SC_HANDLE hscm = NULL, service = NULL;
5659 LPCWSTR comp, key;
5660 LPWSTR name = NULL, disp = NULL, load_order = NULL, serv_name = NULL;
5661 LPWSTR depends = NULL, pass = NULL, args = NULL, image_path = NULL;
5662 DWORD serv_type, start_type, err_control;
5663 BOOL is_vital;
5664 SERVICE_DESCRIPTIONW sd = {NULL};
5665 UINT ret = ERROR_SUCCESS;
5666
5667 comp = MSI_RecordGetString( rec, 12 );
5668 component = msi_get_loaded_component( package, comp );
5669 if (!component)
5670 {
5671 WARN("service component not found\n");
5672 goto done;
5673 }
5674 component->Action = msi_get_component_action( package, component );
5675 if (component->Action != INSTALLSTATE_LOCAL)
5676 {
5677 TRACE("component not scheduled for installation %s\n", debugstr_w(comp));
5678 goto done;
5679 }
5680 hscm = OpenSCManagerW(NULL, SERVICES_ACTIVE_DATABASEW, GENERIC_WRITE);
5681 if (!hscm)
5682 {
5683 ERR("Failed to open the SC Manager!\n");
5684 goto done;
5685 }
5686
5687 start_type = MSI_RecordGetInteger(rec, 5);
5688 if (start_type == SERVICE_BOOT_START || start_type == SERVICE_SYSTEM_START)
5689 goto done;
5690
5691 deformat_string(package, MSI_RecordGetString(rec, 2), &name);
5692 deformat_string(package, MSI_RecordGetString(rec, 3), &disp);
5693 serv_type = MSI_RecordGetInteger(rec, 4);
5694 err_control = MSI_RecordGetInteger(rec, 6);
5695 deformat_string(package, MSI_RecordGetString(rec, 7), &load_order);
5696 deformat_string(package, MSI_RecordGetString(rec, 8), &depends);
5697 deformat_string(package, MSI_RecordGetString(rec, 9), &serv_name);
5698 deformat_string(package, MSI_RecordGetString(rec, 10), &pass);
5699 deformat_string(package, MSI_RecordGetString(rec, 11), &args);
5700 deformat_string(package, MSI_RecordGetString(rec, 13), &sd.lpDescription);
5701
5702 /* Should the complete install fail if CreateService fails? */
5703 is_vital = (err_control & msidbServiceInstallErrorControlVital);
5704
5705 /* Remove the msidbServiceInstallErrorControlVital-flag from err_control.
5706 CreateService (under Windows) would fail if not. */
5707 err_control &= ~msidbServiceInstallErrorControlVital;
5708
5709 /* fetch the service path */
5710 row = MSI_QueryGetRecord(package->db, L"SELECT * FROM `Component` WHERE `Component` = '%s'", comp);
5711 if (!row)
5712 {
5713 ERR("Query failed\n");
5714 goto done;
5715 }
5716 if (!(key = MSI_RecordGetString(row, 6)))
5717 {
5718 msiobj_release(&row->hdr);
5719 goto done;
5720 }
5721 file = msi_get_loaded_file(package, key);
5722 msiobj_release(&row->hdr);
5723 if (!file)
5724 {
5725 ERR("Failed to load the service file\n");
5726 goto done;
5727 }
5728
5729 if (!args || !args[0]) image_path = file->TargetPath;
5730 else
5731 {
5732 int len = lstrlenW(file->TargetPath) + lstrlenW(args) + 2;
5733 if (!(image_path = msi_alloc(len * sizeof(WCHAR))))
5734 {
5735 ret = ERROR_OUTOFMEMORY;
5736 goto done;
5737 }
5738
5739 lstrcpyW(image_path, file->TargetPath);
5740 lstrcatW(image_path, L" ");
5741 lstrcatW(image_path, args);
5742 }
5743 service = CreateServiceW(hscm, name, disp, GENERIC_ALL, serv_type,
5744 start_type, err_control, image_path, load_order,
5745 NULL, depends, serv_name, pass);
5746
5747 if (!service)
5748 {
5749 if (GetLastError() != ERROR_SERVICE_EXISTS)
5750 {
5751 WARN("Failed to create service %s: %d\n", debugstr_w(name), GetLastError());
5752 if (is_vital)
5753 ret = ERROR_INSTALL_FAILURE;
5754
5755 }
5756 }
5757 else if (sd.lpDescription)
5758 {
5759 if (!ChangeServiceConfig2W(service, SERVICE_CONFIG_DESCRIPTION, &sd))
5760 WARN("failed to set service description %u\n", GetLastError());
5761 }
5762
5763 if (image_path != file->TargetPath) msi_free(image_path);
5764 done:
5765 if (service) CloseServiceHandle(service);
5766 if (hscm) CloseServiceHandle(hscm);
5767 msi_free(name);
5768 msi_free(disp);
5769 msi_free(sd.lpDescription);
5770 msi_free(load_order);
5771 msi_free(serv_name);
5772 msi_free(pass);
5773 msi_free(depends);
5774 msi_free(args);
5775
5776 return ret;
5777 }
5778
5779 static UINT ACTION_InstallServices( MSIPACKAGE *package )
5780 {
5781 MSIQUERY *view;
5782 UINT rc;
5783
5784 if (package->script == SCRIPT_NONE)
5785 return msi_schedule_action(package, SCRIPT_INSTALL, L"InstallServices");
5786
5787 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `ServiceInstall`", &view);
5788 if (rc != ERROR_SUCCESS)
5789 return ERROR_SUCCESS;
5790
5791 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallService, package);
5792 msiobj_release(&view->hdr);
5793 return rc;
5794 }
5795
5796 /* converts arg1[~]arg2[~]arg3 to a list of ptrs to the strings */
5797 static LPCWSTR *msi_service_args_to_vector(LPWSTR args, DWORD *numargs)
5798 {
5799 LPCWSTR *vector, *temp_vector;
5800 LPWSTR p, q;
5801 DWORD sep_len;
5802
5803 *numargs = 0;
5804 sep_len = ARRAY_SIZE(L"[~]") - 1;
5805
5806 if (!args)
5807 return NULL;
5808
5809 vector = msi_alloc(sizeof(LPWSTR));
5810 if (!vector)
5811 return NULL;
5812
5813 p = args;
5814 do
5815 {
5816 (*numargs)++;
5817 vector[*numargs - 1] = p;
5818
5819 if ((q = wcsstr(p, L"[~]")))
5820 {
5821 *q = '\0';
5822
5823 temp_vector = msi_realloc(vector, (*numargs + 1) * sizeof(LPWSTR));
5824 if (!temp_vector)
5825 {
5826 msi_free(vector);
5827 return NULL;
5828 }
5829 vector = temp_vector;
5830
5831 p = q + sep_len;
5832 }
5833 } while (q);
5834
5835 return vector;
5836 }
5837
5838 static UINT ITERATE_StartService(MSIRECORD *rec, LPVOID param)
5839 {
5840 MSIPACKAGE *package = param;
5841 MSICOMPONENT *comp;
5842 MSIRECORD *uirow;
5843 SC_HANDLE scm = NULL, service = NULL;
5844 LPCWSTR component, *vector = NULL;
5845 LPWSTR name, args, display_name = NULL;
5846 DWORD event, numargs, len, wait, dummy;
5847 UINT r = ERROR_FUNCTION_FAILED;
5848 SERVICE_STATUS_PROCESS status;
5849 ULONGLONG start_time;
5850
5851 component = MSI_RecordGetString(rec, 6);
5852 comp = msi_get_loaded_component(package, component);
5853 if (!comp)
5854 return ERROR_SUCCESS;
5855
5856 event = MSI_RecordGetInteger( rec, 3 );
5857 deformat_string( package, MSI_RecordGetString( rec, 2 ), &name );
5858
5859 comp->Action = msi_get_component_action( package, comp );
5860 if (!(comp->Action == INSTALLSTATE_LOCAL && (event & msidbServiceControlEventStart)) &&
5861 !(comp->Action == INSTALLSTATE_ABSENT && (event & msidbServiceControlEventUninstallStart)))
5862 {
5863 TRACE("not starting %s\n", debugstr_w(name));
5864 msi_free( name );
5865 return ERROR_SUCCESS;
5866 }
5867
5868 deformat_string(package, MSI_RecordGetString(rec, 4), &args);
5869 wait = MSI_RecordGetInteger(rec, 5);
5870
5871 scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
5872 if (!scm)
5873 {
5874 ERR("Failed to open the service control manager\n");
5875 goto done;
5876 }
5877
5878 len = 0;
5879 if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
5880 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
5881 {
5882 if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
5883 GetServiceDisplayNameW( scm, name, display_name, &len );
5884 }
5885
5886 service = OpenServiceW(scm, name, SERVICE_START|SERVICE_QUERY_STATUS);
5887 if (!service)
5888 {
5889 ERR("Failed to open service %s (%u)\n", debugstr_w(name), GetLastError());
5890 goto done;
5891 }
5892
5893 vector = msi_service_args_to_vector(args, &numargs);
5894
5895 if (!StartServiceW(service, numargs, vector) &&
5896 GetLastError() != ERROR_SERVICE_ALREADY_RUNNING)
5897 {
5898 ERR("Failed to start service %s (%u)\n", debugstr_w(name), GetLastError());
5899 goto done;
5900 }
5901
5902 r = ERROR_SUCCESS;
5903 if (wait)
5904 {
5905 /* wait for at most 30 seconds for the service to be up and running */
5906 if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO,
5907 (BYTE *)&status, sizeof(SERVICE_STATUS_PROCESS), &dummy))
5908 {
5909 TRACE("failed to query service status (%u)\n", GetLastError());
5910 goto done;
5911 }
5912 start_time = GetTickCount64();
5913 while (status.dwCurrentState == SERVICE_START_PENDING)
5914 {
5915 if (GetTickCount64() - start_time > 30000) break;
5916 Sleep(1000);
5917 if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO,
5918 (BYTE *)&status, sizeof(SERVICE_STATUS_PROCESS), &dummy))
5919 {
5920 TRACE("failed to query service status (%u)\n", GetLastError());
5921 goto done;
5922 }
5923 }
5924 if (status.dwCurrentState != SERVICE_RUNNING)
5925 {
5926 WARN("service failed to start %u\n", status.dwCurrentState);
5927 r = ERROR_FUNCTION_FAILED;
5928 }
5929 }
5930
5931 done:
5932 uirow = MSI_CreateRecord( 2 );
5933 MSI_RecordSetStringW( uirow, 1, display_name );
5934 MSI_RecordSetStringW( uirow, 2, name );
5935 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
5936 msiobj_release( &uirow->hdr );
5937
5938 if (service) CloseServiceHandle(service);
5939 if (scm) CloseServiceHandle(scm);
5940
5941 msi_free(name);
5942 msi_free(args);
5943 msi_free(vector);
5944 msi_free(display_name);
5945 return r;
5946 }
5947
5948 static UINT ACTION_StartServices( MSIPACKAGE *package )
5949 {
5950 MSIQUERY *view;
5951 UINT rc;
5952
5953 if (package->script == SCRIPT_NONE)
5954 return msi_schedule_action(package, SCRIPT_INSTALL, L"StartServices");
5955
5956 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `ServiceControl`", &view);
5957 if (rc != ERROR_SUCCESS)
5958 return ERROR_SUCCESS;
5959
5960 rc = MSI_IterateRecords(view, NULL, ITERATE_StartService, package);
5961 msiobj_release(&view->hdr);
5962 return rc;
5963 }
5964
5965 static BOOL stop_service_dependents(SC_HANDLE scm, SC_HANDLE service)
5966 {
5967 DWORD i, needed, count;
5968 ENUM_SERVICE_STATUSW *dependencies;
5969 SERVICE_STATUS ss;
5970 SC_HANDLE depserv;
5971 BOOL stopped, ret = FALSE;
5972
5973 if (EnumDependentServicesW(service, SERVICE_ACTIVE, NULL,
5974 0, &needed, &count))
5975 return TRUE;
5976
5977 if (GetLastError() != ERROR_MORE_DATA)
5978 return FALSE;
5979
5980 dependencies = msi_alloc(needed);
5981 if (!dependencies)
5982 return FALSE;
5983
5984 if (!EnumDependentServicesW(service, SERVICE_ACTIVE, dependencies,
5985 needed, &needed, &count))
5986 goto done;
5987
5988 for (i = 0; i < count; i++)
5989 {
5990 depserv = OpenServiceW(scm, dependencies[i].lpServiceName,
5991 SERVICE_STOP | SERVICE_QUERY_STATUS);
5992 if (!depserv)
5993 goto done;
5994
5995 stopped = ControlService(depserv, SERVICE_CONTROL_STOP, &ss);
5996 CloseServiceHandle(depserv);
5997 if (!stopped)
5998 goto done;
5999 }
6000
6001 ret = TRUE;
6002
6003 done:
6004 msi_free(dependencies);
6005 return ret;
6006 }
6007
6008 static UINT stop_service( LPCWSTR name )
6009 {
6010 SC_HANDLE scm = NULL, service = NULL;
6011 SERVICE_STATUS status;
6012 SERVICE_STATUS_PROCESS ssp;
6013 DWORD needed;
6014
6015 scm = OpenSCManagerW(NULL, NULL, SC_MANAGER_ALL_ACCESS);
6016 if (!scm)
6017 {
6018 WARN("Failed to open the SCM: %d\n", GetLastError());
6019 goto done;
6020 }
6021
6022 service = OpenServiceW(scm, name,
6023 SERVICE_STOP |
6024 SERVICE_QUERY_STATUS |
6025 SERVICE_ENUMERATE_DEPENDENTS);
6026 if (!service)
6027 {
6028 WARN("Failed to open service (%s): %d\n", debugstr_w(name), GetLastError());
6029 goto done;
6030 }
6031
6032 if (!QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO, (LPBYTE)&ssp,
6033 sizeof(SERVICE_STATUS_PROCESS), &needed))
6034 {
6035 WARN("Failed to query service status (%s): %d\n", debugstr_w(name), GetLastError());
6036 goto done;
6037 }
6038
6039 if (ssp.dwCurrentState == SERVICE_STOPPED)
6040 goto done;
6041
6042 stop_service_dependents(scm, service);
6043
6044 if (!ControlService(service, SERVICE_CONTROL_STOP, &status))
6045 WARN("Failed to stop service (%s): %d\n", debugstr_w(name), GetLastError());
6046
6047 done:
6048 if (service) CloseServiceHandle(service);
6049 if (scm) CloseServiceHandle(scm);
6050
6051 return ERROR_SUCCESS;
6052 }
6053
6054 static UINT ITERATE_StopService( MSIRECORD *rec, LPVOID param )
6055 {
6056 MSIPACKAGE *package = param;
6057 MSICOMPONENT *comp;
6058 MSIRECORD *uirow;
6059 LPCWSTR component;
6060 WCHAR *name, *display_name = NULL;
6061 DWORD event, len;
6062 SC_HANDLE scm;
6063
6064 component = MSI_RecordGetString( rec, 6 );
6065 comp = msi_get_loaded_component( package, component );
6066 if (!comp)
6067 return ERROR_SUCCESS;
6068
6069 event = MSI_RecordGetInteger( rec, 3 );
6070 deformat_string( package, MSI_RecordGetString( rec, 2 ), &name );
6071
6072 comp->Action = msi_get_component_action( package, comp );
6073 if (!(comp->Action == INSTALLSTATE_LOCAL && (event & msidbServiceControlEventStop)) &&
6074 !(comp->Action == INSTALLSTATE_ABSENT && (event & msidbServiceControlEventUninstallStop)))
6075 {
6076 TRACE("not stopping %s\n", debugstr_w(name));
6077 msi_free( name );
6078 return ERROR_SUCCESS;
6079 }
6080
6081 scm = OpenSCManagerW( NULL, NULL, SC_MANAGER_CONNECT );
6082 if (!scm)
6083 {
6084 ERR("Failed to open the service control manager\n");
6085 goto done;
6086 }
6087
6088 len = 0;
6089 if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
6090 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
6091 {
6092 if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
6093 GetServiceDisplayNameW( scm, name, display_name, &len );
6094 }
6095 CloseServiceHandle( scm );
6096
6097 stop_service( name );
6098
6099 done:
6100 uirow = MSI_CreateRecord( 2 );
6101 MSI_RecordSetStringW( uirow, 1, display_name );
6102 MSI_RecordSetStringW( uirow, 2, name );
6103 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
6104 msiobj_release( &uirow->hdr );
6105
6106 msi_free( name );
6107 msi_free( display_name );
6108 return ERROR_SUCCESS;
6109 }
6110
6111 static UINT ACTION_StopServices( MSIPACKAGE *package )
6112 {
6113 MSIQUERY *view;
6114 UINT rc;
6115
6116 if (package->script == SCRIPT_NONE)
6117 return msi_schedule_action(package, SCRIPT_INSTALL, L"StopServices");
6118
6119 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `ServiceControl`", &view);
6120 if (rc != ERROR_SUCCESS)
6121 return ERROR_SUCCESS;
6122
6123 rc = MSI_IterateRecords(view, NULL, ITERATE_StopService, package);
6124 msiobj_release(&view->hdr);
6125 return rc;
6126 }
6127
6128 static UINT ITERATE_DeleteService( MSIRECORD *rec, LPVOID param )
6129 {
6130 MSIPACKAGE *package = param;
6131 MSICOMPONENT *comp;
6132 MSIRECORD *uirow;
6133 LPWSTR name = NULL, display_name = NULL;
6134 DWORD event, len;
6135 SC_HANDLE scm = NULL, service = NULL;
6136
6137 comp = msi_get_loaded_component( package, MSI_RecordGetString(rec, 6) );
6138 if (!comp)
6139 return ERROR_SUCCESS;
6140
6141 event = MSI_RecordGetInteger( rec, 3 );
6142 deformat_string( package, MSI_RecordGetString(rec, 2), &name );
6143
6144 comp->Action = msi_get_component_action( package, comp );
6145 if (!(comp->Action == INSTALLSTATE_LOCAL && (event & msidbServiceControlEventDelete)) &&
6146 !(comp->Action == INSTALLSTATE_ABSENT && (event & msidbServiceControlEventUninstallDelete)))
6147 {
6148 TRACE("service %s not scheduled for removal\n", debugstr_w(name));
6149 msi_free( name );
6150 return ERROR_SUCCESS;
6151 }
6152 stop_service( name );
6153
6154 scm = OpenSCManagerW( NULL, NULL, SC_MANAGER_ALL_ACCESS );
6155 if (!scm)
6156 {
6157 WARN("Failed to open the SCM: %d\n", GetLastError());
6158 goto done;
6159 }
6160
6161 len = 0;
6162 if (!GetServiceDisplayNameW( scm, name, NULL, &len ) &&
6163 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
6164 {
6165 if ((display_name = msi_alloc( ++len * sizeof(WCHAR ))))
6166 GetServiceDisplayNameW( scm, name, display_name, &len );
6167 }
6168
6169 service = OpenServiceW( scm, name, DELETE );
6170 if (!service)
6171 {
6172 WARN("Failed to open service (%s): %u\n", debugstr_w(name), GetLastError());
6173 goto done;
6174 }
6175
6176 if (!DeleteService( service ))
6177 WARN("Failed to delete service (%s): %u\n", debugstr_w(name), GetLastError());
6178
6179 done:
6180 uirow = MSI_CreateRecord( 2 );
6181 MSI_RecordSetStringW( uirow, 1, display_name );
6182 MSI_RecordSetStringW( uirow, 2, name );
6183 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
6184 msiobj_release( &uirow->hdr );
6185
6186 if (service) CloseServiceHandle( service );
6187 if (scm) CloseServiceHandle( scm );
6188 msi_free( name );
6189 msi_free( display_name );
6190
6191 return ERROR_SUCCESS;
6192 }
6193
6194 static UINT ACTION_DeleteServices( MSIPACKAGE *package )
6195 {
6196 MSIQUERY *view;
6197 UINT rc;
6198
6199 if (package->script == SCRIPT_NONE)
6200 return msi_schedule_action(package, SCRIPT_INSTALL, L"DeleteServices");
6201
6202 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `ServiceControl`", &view );
6203 if (rc != ERROR_SUCCESS)
6204 return ERROR_SUCCESS;
6205
6206 rc = MSI_IterateRecords( view, NULL, ITERATE_DeleteService, package );
6207 msiobj_release( &view->hdr );
6208 return rc;
6209 }
6210
6211 static UINT ITERATE_InstallODBCDriver( MSIRECORD *rec, LPVOID param )
6212 {
6213 MSIPACKAGE *package = param;
6214 LPWSTR driver, driver_path, ptr;
6215 WCHAR outpath[MAX_PATH];
6216 MSIFILE *driver_file = NULL, *setup_file = NULL;
6217 MSICOMPONENT *comp;
6218 MSIRECORD *uirow;
6219 LPCWSTR desc, file_key, component;
6220 DWORD len, usage;
6221 UINT r = ERROR_SUCCESS;
6222
6223 component = MSI_RecordGetString( rec, 2 );
6224 comp = msi_get_loaded_component( package, component );
6225 if (!comp)
6226 return ERROR_SUCCESS;
6227
6228 comp->Action = msi_get_component_action( package, comp );
6229 if (comp->Action != INSTALLSTATE_LOCAL)
6230 {
6231 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
6232 return ERROR_SUCCESS;
6233 }
6234 desc = MSI_RecordGetString(rec, 3);
6235
6236 file_key = MSI_RecordGetString( rec, 4 );
6237 if (file_key) driver_file = msi_get_loaded_file( package, file_key );
6238
6239 file_key = MSI_RecordGetString( rec, 5 );
6240 if (file_key) setup_file = msi_get_loaded_file( package, file_key );
6241
6242 if (!driver_file)
6243 {
6244 ERR("ODBC Driver entry not found!\n");
6245 return ERROR_FUNCTION_FAILED;
6246 }
6247
6248 len = lstrlenW(desc) + lstrlenW(L"Driver=%s") + lstrlenW(driver_file->FileName);
6249 if (setup_file)
6250 len += lstrlenW(L"Setup=%s") + lstrlenW(setup_file->FileName);
6251 len += lstrlenW(L"FileUsage=1") + 2; /* \0\0 */
6252
6253 driver = msi_alloc(len * sizeof(WCHAR));
6254 if (!driver)
6255 return ERROR_OUTOFMEMORY;
6256
6257 ptr = driver;
6258 lstrcpyW(ptr, desc);
6259 ptr += lstrlenW(ptr) + 1;
6260
6261 len = swprintf(ptr, len - (ptr - driver), L"Driver=%s", driver_file->FileName);
6262 ptr += len + 1;
6263
6264 if (setup_file)
6265 {
6266 len = swprintf(ptr, len - (ptr - driver), L"Setup=%s", setup_file->FileName);
6267 ptr += len + 1;
6268 }
6269
6270 lstrcpyW(ptr, L"FileUsage=1");
6271 ptr += lstrlenW(ptr) + 1;
6272 *ptr = '\0';
6273
6274 if (!driver_file->TargetPath)
6275 {
6276 const WCHAR *dir = msi_get_target_folder( package, driver_file->Component->Directory );
6277 driver_file->TargetPath = msi_build_directory_name( 2, dir, driver_file->FileName );
6278 }
6279 driver_path = strdupW(driver_file->TargetPath);
6280 ptr = wcsrchr(driver_path, '\\');
6281 if (ptr) *ptr = '\0';
6282
6283 if (!SQLInstallDriverExW(driver, driver_path, outpath, MAX_PATH,
6284 NULL, ODBC_INSTALL_COMPLETE, &usage))
6285 {
6286 ERR("Failed to install SQL driver!\n");
6287 r = ERROR_FUNCTION_FAILED;
6288 }
6289
6290 uirow = MSI_CreateRecord( 5 );
6291 MSI_RecordSetStringW( uirow, 1, desc );
6292 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6293 MSI_RecordSetStringW( uirow, 3, driver_file->Component->Directory );
6294 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
6295 msiobj_release( &uirow->hdr );
6296
6297 msi_free(driver);
6298 msi_free(driver_path);
6299
6300 return r;
6301 }
6302
6303 static UINT ITERATE_InstallODBCTranslator( MSIRECORD *rec, LPVOID param )
6304 {
6305 MSIPACKAGE *package = param;
6306 LPWSTR translator, translator_path, ptr;
6307 WCHAR outpath[MAX_PATH];
6308 MSIFILE *translator_file = NULL, *setup_file = NULL;
6309 MSICOMPONENT *comp;
6310 MSIRECORD *uirow;
6311 LPCWSTR desc, file_key, component;
6312 DWORD len, usage;
6313 UINT r = ERROR_SUCCESS;
6314
6315 component = MSI_RecordGetString( rec, 2 );
6316 comp = msi_get_loaded_component( package, component );
6317 if (!comp)
6318 return ERROR_SUCCESS;
6319
6320 comp->Action = msi_get_component_action( package, comp );
6321 if (comp->Action != INSTALLSTATE_LOCAL)
6322 {
6323 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
6324 return ERROR_SUCCESS;
6325 }
6326 desc = MSI_RecordGetString(rec, 3);
6327
6328 file_key = MSI_RecordGetString( rec, 4 );
6329 if (file_key) translator_file = msi_get_loaded_file( package, file_key );
6330
6331 file_key = MSI_RecordGetString( rec, 5 );
6332 if (file_key) setup_file = msi_get_loaded_file( package, file_key );
6333
6334 if (!translator_file)
6335 {
6336 ERR("ODBC Translator entry not found!\n");
6337 return ERROR_FUNCTION_FAILED;
6338 }
6339
6340 len = lstrlenW(desc) + lstrlenW(L"Translator=%s") + lstrlenW(translator_file->FileName) + 2; /* \0\0 */
6341 if (setup_file)
6342 len += lstrlenW(L"Setup=%s") + lstrlenW(setup_file->FileName);
6343
6344 translator = msi_alloc(len * sizeof(WCHAR));
6345 if (!translator)
6346 return ERROR_OUTOFMEMORY;
6347
6348 ptr = translator;
6349 lstrcpyW(ptr, desc);
6350 ptr += lstrlenW(ptr) + 1;
6351
6352 len = swprintf(ptr, len - (ptr - translator), L"Translator=%s", translator_file->FileName);
6353 ptr += len + 1;
6354
6355 if (setup_file)
6356 {
6357 len = swprintf(ptr, len - (ptr - translator), L"Setup=%s", setup_file->FileName);
6358 ptr += len + 1;
6359 }
6360 *ptr = '\0';
6361
6362 translator_path = strdupW(translator_file->TargetPath);
6363 ptr = wcsrchr(translator_path, '\\');
6364 if (ptr) *ptr = '\0';
6365
6366 if (!SQLInstallTranslatorExW(translator, translator_path, outpath, MAX_PATH,
6367 NULL, ODBC_INSTALL_COMPLETE, &usage))
6368 {
6369 ERR("Failed to install SQL translator!\n");
6370 r = ERROR_FUNCTION_FAILED;
6371 }
6372
6373 uirow = MSI_CreateRecord( 5 );
6374 MSI_RecordSetStringW( uirow, 1, desc );
6375 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6376 MSI_RecordSetStringW( uirow, 3, translator_file->Component->Directory );
6377 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
6378 msiobj_release( &uirow->hdr );
6379
6380 msi_free(translator);
6381 msi_free(translator_path);
6382
6383 return r;
6384 }
6385
6386 static UINT ITERATE_InstallODBCDataSource( MSIRECORD *rec, LPVOID param )
6387 {
6388 MSIPACKAGE *package = param;
6389 MSICOMPONENT *comp;
6390 LPWSTR attrs;
6391 LPCWSTR desc, driver, component;
6392 WORD request = ODBC_ADD_SYS_DSN;
6393 INT registration;
6394 DWORD len;
6395 UINT r = ERROR_SUCCESS;
6396 MSIRECORD *uirow;
6397
6398 component = MSI_RecordGetString( rec, 2 );
6399 comp = msi_get_loaded_component( package, component );
6400 if (!comp)
6401 return ERROR_SUCCESS;
6402
6403 comp->Action = msi_get_component_action( package, comp );
6404 if (comp->Action != INSTALLSTATE_LOCAL)
6405 {
6406 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
6407 return ERROR_SUCCESS;
6408 }
6409
6410 desc = MSI_RecordGetString(rec, 3);
6411 driver = MSI_RecordGetString(rec, 4);
6412 registration = MSI_RecordGetInteger(rec, 5);
6413
6414 if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_ADD_SYS_DSN;
6415 else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_ADD_DSN;
6416
6417 len = lstrlenW(L"DSN=%s") + lstrlenW(desc) + 2; /* \0\0 */
6418 attrs = msi_alloc(len * sizeof(WCHAR));
6419 if (!attrs)
6420 return ERROR_OUTOFMEMORY;
6421
6422 len = swprintf(attrs, len, L"DSN=%s", desc);
6423 attrs[len + 1] = 0;
6424
6425 if (!SQLConfigDataSourceW(NULL, request, driver, attrs))
6426 WARN("Failed to install SQL data source!\n");
6427
6428 uirow = MSI_CreateRecord( 5 );
6429 MSI_RecordSetStringW( uirow, 1, desc );
6430 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6431 MSI_RecordSetInteger( uirow, 3, request );
6432 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
6433 msiobj_release( &uirow->hdr );
6434
6435 msi_free(attrs);
6436
6437 return r;
6438 }
6439
6440 static UINT ACTION_InstallODBC( MSIPACKAGE *package )
6441 {
6442 MSIQUERY *view;
6443 UINT rc;
6444
6445 if (package->script == SCRIPT_NONE)
6446 return msi_schedule_action(package, SCRIPT_INSTALL, L"InstallODBC");
6447
6448 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `ODBCDriver`", &view);
6449 if (rc == ERROR_SUCCESS)
6450 {
6451 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDriver, package);
6452 msiobj_release(&view->hdr);
6453 if (rc != ERROR_SUCCESS)
6454 return rc;
6455 }
6456 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `ODBCTranslator`", &view);
6457 if (rc == ERROR_SUCCESS)
6458 {
6459 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCTranslator, package);
6460 msiobj_release(&view->hdr);
6461 if (rc != ERROR_SUCCESS)
6462 return rc;
6463 }
6464 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `ODBCDataSource`", &view);
6465 if (rc == ERROR_SUCCESS)
6466 {
6467 rc = MSI_IterateRecords(view, NULL, ITERATE_InstallODBCDataSource, package);
6468 msiobj_release(&view->hdr);
6469 if (rc != ERROR_SUCCESS)
6470 return rc;
6471 }
6472 return ERROR_SUCCESS;
6473 }
6474
6475 static UINT ITERATE_RemoveODBCDriver( MSIRECORD *rec, LPVOID param )
6476 {
6477 MSIPACKAGE *package = param;
6478 MSICOMPONENT *comp;
6479 MSIRECORD *uirow;
6480 DWORD usage;
6481 LPCWSTR desc, component;
6482
6483 component = MSI_RecordGetString( rec, 2 );
6484 comp = msi_get_loaded_component( package, component );
6485 if (!comp)
6486 return ERROR_SUCCESS;
6487
6488 comp->Action = msi_get_component_action( package, comp );
6489 if (comp->Action != INSTALLSTATE_ABSENT)
6490 {
6491 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
6492 return ERROR_SUCCESS;
6493 }
6494
6495 desc = MSI_RecordGetString( rec, 3 );
6496 if (!SQLRemoveDriverW( desc, FALSE, &usage ))
6497 {
6498 WARN("Failed to remove ODBC driver\n");
6499 }
6500 else if (!usage)
6501 {
6502 FIXME("Usage count reached 0\n");
6503 }
6504
6505 uirow = MSI_CreateRecord( 2 );
6506 MSI_RecordSetStringW( uirow, 1, desc );
6507 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6508 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
6509 msiobj_release( &uirow->hdr );
6510
6511 return ERROR_SUCCESS;
6512 }
6513
6514 static UINT ITERATE_RemoveODBCTranslator( MSIRECORD *rec, LPVOID param )
6515 {
6516 MSIPACKAGE *package = param;
6517 MSICOMPONENT *comp;
6518 MSIRECORD *uirow;
6519 DWORD usage;
6520 LPCWSTR desc, component;
6521
6522 component = MSI_RecordGetString( rec, 2 );
6523 comp = msi_get_loaded_component( package, component );
6524 if (!comp)
6525 return ERROR_SUCCESS;
6526
6527 comp->Action = msi_get_component_action( package, comp );
6528 if (comp->Action != INSTALLSTATE_ABSENT)
6529 {
6530 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
6531 return ERROR_SUCCESS;
6532 }
6533
6534 desc = MSI_RecordGetString( rec, 3 );
6535 if (!SQLRemoveTranslatorW( desc, &usage ))
6536 {
6537 WARN("Failed to remove ODBC translator\n");
6538 }
6539 else if (!usage)
6540 {
6541 FIXME("Usage count reached 0\n");
6542 }
6543
6544 uirow = MSI_CreateRecord( 2 );
6545 MSI_RecordSetStringW( uirow, 1, desc );
6546 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6547 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
6548 msiobj_release( &uirow->hdr );
6549
6550 return ERROR_SUCCESS;
6551 }
6552
6553 static UINT ITERATE_RemoveODBCDataSource( MSIRECORD *rec, LPVOID param )
6554 {
6555 MSIPACKAGE *package = param;
6556 MSICOMPONENT *comp;
6557 MSIRECORD *uirow;
6558 LPWSTR attrs;
6559 LPCWSTR desc, driver, component;
6560 WORD request = ODBC_REMOVE_SYS_DSN;
6561 INT registration;
6562 DWORD len;
6563
6564 component = MSI_RecordGetString( rec, 2 );
6565 comp = msi_get_loaded_component( package, component );
6566 if (!comp)
6567 return ERROR_SUCCESS;
6568
6569 comp->Action = msi_get_component_action( package, comp );
6570 if (comp->Action != INSTALLSTATE_ABSENT)
6571 {
6572 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
6573 return ERROR_SUCCESS;
6574 }
6575
6576 desc = MSI_RecordGetString( rec, 3 );
6577 driver = MSI_RecordGetString( rec, 4 );
6578 registration = MSI_RecordGetInteger( rec, 5 );
6579
6580 if (registration == msidbODBCDataSourceRegistrationPerMachine) request = ODBC_REMOVE_SYS_DSN;
6581 else if (registration == msidbODBCDataSourceRegistrationPerUser) request = ODBC_REMOVE_DSN;
6582
6583 len = lstrlenW( L"DSN=%s" ) + lstrlenW( desc ) + 2; /* \0\0 */
6584 attrs = msi_alloc( len * sizeof(WCHAR) );
6585 if (!attrs)
6586 return ERROR_OUTOFMEMORY;
6587
6588 FIXME("Use ODBCSourceAttribute table\n");
6589
6590 len = swprintf( attrs, len, L"DSN=%s", desc );
6591 attrs[len + 1] = 0;
6592
6593 if (!SQLConfigDataSourceW( NULL, request, driver, attrs ))
6594 {
6595 WARN("Failed to remove ODBC data source\n");
6596 }
6597 msi_free( attrs );
6598
6599 uirow = MSI_CreateRecord( 3 );
6600 MSI_RecordSetStringW( uirow, 1, desc );
6601 MSI_RecordSetStringW( uirow, 2, MSI_RecordGetString(rec, 2) );
6602 MSI_RecordSetInteger( uirow, 3, request );
6603 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
6604 msiobj_release( &uirow->hdr );
6605
6606 return ERROR_SUCCESS;
6607 }
6608
6609 static UINT ACTION_RemoveODBC( MSIPACKAGE *package )
6610 {
6611 MSIQUERY *view;
6612 UINT rc;
6613
6614 if (package->script == SCRIPT_NONE)
6615 return msi_schedule_action(package, SCRIPT_INSTALL, L"RemoveODBC");
6616
6617 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `ODBCDriver`", &view );
6618 if (rc == ERROR_SUCCESS)
6619 {
6620 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCDriver, package );
6621 msiobj_release( &view->hdr );
6622 if (rc != ERROR_SUCCESS)
6623 return rc;
6624 }
6625 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `ODBCTranslator`", &view );
6626 if (rc == ERROR_SUCCESS)
6627 {
6628 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCTranslator, package );
6629 msiobj_release( &view->hdr );
6630 if (rc != ERROR_SUCCESS)
6631 return rc;
6632 }
6633 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `ODBCDataSource`", &view );
6634 if (rc == ERROR_SUCCESS)
6635 {
6636 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveODBCDataSource, package );
6637 msiobj_release( &view->hdr );
6638 if (rc != ERROR_SUCCESS)
6639 return rc;
6640 }
6641 return ERROR_SUCCESS;
6642 }
6643
6644 #define ENV_ACT_SETALWAYS 0x1
6645 #define ENV_ACT_SETABSENT 0x2
6646 #define ENV_ACT_REMOVE 0x4
6647 #define ENV_ACT_REMOVEMATCH 0x8
6648
6649 #define ENV_MOD_MACHINE 0x20000000
6650 #define ENV_MOD_APPEND 0x40000000
6651 #define ENV_MOD_PREFIX 0x80000000
6652 #define ENV_MOD_MASK 0xC0000000
6653
6654 #define check_flag_combo(x, y) ((x) & ~(y)) == (y)
6655
6656 static UINT env_parse_flags( LPCWSTR *name, LPCWSTR *value, DWORD *flags )
6657 {
6658 const WCHAR *cptr = *name;
6659
6660 *flags = 0;
6661 while (*cptr)
6662 {
6663 if (*cptr == '=')
6664 *flags |= ENV_ACT_SETALWAYS;
6665 else if (*cptr == '+')
6666 *flags |= ENV_ACT_SETABSENT;
6667 else if (*cptr == '-')
6668 *flags |= ENV_ACT_REMOVE;
6669 else if (*cptr == '!')
6670 *flags |= ENV_ACT_REMOVEMATCH;
6671 else if (*cptr == '*')
6672 *flags |= ENV_MOD_MACHINE | ENV_ACT_REMOVE;
6673 else
6674 break;
6675
6676 cptr++;
6677 (*name)++;
6678 }
6679
6680 if (!*cptr)
6681 {
6682 ERR("Missing environment variable\n");
6683 return ERROR_FUNCTION_FAILED;
6684 }
6685
6686 if (*value)
6687 {
6688 LPCWSTR ptr = *value;
6689 if (!wcsncmp(ptr, L"[~]", 3))
6690 {
6691 if (ptr[3] == ';')
6692 {
6693 *flags |= ENV_MOD_APPEND;
6694 *value += 3;
6695 }
6696 else
6697 {
6698 *value = NULL;
6699 }
6700 }
6701 else if (lstrlenW(*value) >= 3)
6702 {
6703 ptr += lstrlenW(ptr) - 3;
6704 if (!wcscmp( ptr, L"[~]" ))
6705 {
6706 if ((ptr-1) > *value && *(ptr-1) == ';')
6707 {
6708 *flags |= ENV_MOD_PREFIX;
6709 /* the "[~]" will be removed by deformat_string */;
6710 }
6711 else
6712 {
6713 *value = NULL;
6714 }
6715 }
6716 }
6717 }
6718
6719 if (check_flag_combo(*flags, ENV_ACT_SETALWAYS | ENV_ACT_SETABSENT) ||
6720 check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETABSENT) ||
6721 check_flag_combo(*flags, ENV_ACT_REMOVEMATCH | ENV_ACT_SETALWAYS) ||
6722 check_flag_combo(*flags, ENV_ACT_SETABSENT | ENV_MOD_MASK))
6723 {
6724 ERR("Invalid flags: %08x\n", *flags);
6725 return ERROR_FUNCTION_FAILED;
6726 }
6727
6728 if (!*flags)
6729 *flags = ENV_ACT_SETALWAYS | ENV_ACT_REMOVE;
6730
6731 return ERROR_SUCCESS;
6732 }
6733
6734 static UINT open_env_key( DWORD flags, HKEY *key )
6735 {
6736 const WCHAR *env;
6737 HKEY root;
6738 LONG res;
6739
6740 if (flags & ENV_MOD_MACHINE)
6741 {
6742 env = L"System\\CurrentControlSet\\Control\\Session Manager\\Environment";
6743 root = HKEY_LOCAL_MACHINE;
6744 }
6745 else
6746 {
6747 env = L"Environment";
6748 root = HKEY_CURRENT_USER;
6749 }
6750
6751 res = RegOpenKeyExW( root, env, 0, KEY_ALL_ACCESS, key );
6752 if (res != ERROR_SUCCESS)
6753 {
6754 WARN("Failed to open key %s (%d)\n", debugstr_w(env), res);
6755 return ERROR_FUNCTION_FAILED;
6756 }
6757
6758 return ERROR_SUCCESS;
6759 }
6760
6761 static UINT ITERATE_WriteEnvironmentString( MSIRECORD *rec, LPVOID param )
6762 {
6763 MSIPACKAGE *package = param;
6764 LPCWSTR name, value, component;
6765 WCHAR *data = NULL, *newval = NULL, *deformatted = NULL, *p, *q;
6766 DWORD flags, type, size, len, len_value = 0;
6767 UINT res;
6768 HKEY env = NULL;
6769 MSICOMPONENT *comp;
6770 MSIRECORD *uirow;
6771 int action = 0, found = 0;
6772
6773 component = MSI_RecordGetString(rec, 4);
6774 comp = msi_get_loaded_component(package, component);
6775 if (!comp)
6776 return ERROR_SUCCESS;
6777
6778 comp->Action = msi_get_component_action( package, comp );
6779 if (comp->Action != INSTALLSTATE_LOCAL)
6780 {
6781 TRACE("component not scheduled for installation %s\n", debugstr_w(component));
6782 return ERROR_SUCCESS;
6783 }
6784 name = MSI_RecordGetString(rec, 2);
6785 value = MSI_RecordGetString(rec, 3);
6786
6787 TRACE("name %s value %s\n", debugstr_w(name), debugstr_w(value));
6788
6789 res = env_parse_flags(&name, &value, &flags);
6790 if (res != ERROR_SUCCESS || !value)
6791 goto done;
6792
6793 if (value && !deformat_string(package, value, &deformatted))
6794 {
6795 res = ERROR_OUTOFMEMORY;
6796 goto done;
6797 }
6798
6799 if ((value = deformatted))
6800 {
6801 if (flags & ENV_MOD_PREFIX)
6802 {
6803 p = wcsrchr( value, ';' );
6804 len_value = p - value;
6805 }
6806 else if (flags & ENV_MOD_APPEND)
6807 {
6808 value = wcschr( value, ';' ) + 1;
6809 len_value = lstrlenW( value );
6810 }
6811 else len_value = lstrlenW( value );
6812 }
6813
6814 res = open_env_key( flags, &env );
6815 if (res != ERROR_SUCCESS)
6816 goto done;
6817
6818 if (flags & ENV_MOD_MACHINE)
6819 action |= 0x20000000;
6820
6821 size = 0;
6822 type = REG_SZ;
6823 res = RegQueryValueExW(env, name, NULL, &type, NULL, &size);
6824 if ((res != ERROR_SUCCESS && res != ERROR_FILE_NOT_FOUND) ||
6825 (res == ERROR_SUCCESS && type != REG_SZ && type != REG_EXPAND_SZ))
6826 goto done;
6827
6828 if ((res == ERROR_FILE_NOT_FOUND || !(flags & ENV_MOD_MASK)))
6829 {
6830 action = 0x2;
6831
6832 /* Nothing to do. */
6833 if (!value)
6834 {
6835 res = ERROR_SUCCESS;
6836 goto done;
6837 }
6838 size = (lstrlenW(value) + 1) * sizeof(WCHAR);
6839 newval = strdupW(value);
6840 if (!newval)
6841 {
6842 res = ERROR_OUTOFMEMORY;
6843 goto done;
6844 }
6845 }
6846 else
6847 {
6848 action = 0x1;
6849
6850 /* Contrary to MSDN, +-variable to [~];path works */
6851 if (flags & ENV_ACT_SETABSENT && !(flags & ENV_MOD_MASK))
6852 {
6853 res = ERROR_SUCCESS;
6854 goto done;
6855 }
6856
6857 if (!(p = q = data = msi_alloc( size )))
6858 {
6859 msi_free(deformatted);
6860 RegCloseKey(env);
6861 return ERROR_OUTOFMEMORY;
6862 }
6863
6864 res = RegQueryValueExW( env, name, NULL, &type, (BYTE *)data, &size );
6865 if (res != ERROR_SUCCESS)
6866 goto done;
6867
6868 if (flags & ENV_ACT_REMOVEMATCH && (!value || !wcscmp( data, value )))
6869 {
6870 action = 0x4;
6871 res = RegDeleteValueW(env, name);
6872 if (res != ERROR_SUCCESS)
6873 WARN("Failed to remove value %s (%d)\n", debugstr_w(name), res);
6874 goto done;
6875 }
6876
6877 for (;;)
6878 {
6879 while (*q && *q != ';') q++;
6880 len = q - p;
6881 if (value && len == len_value && !memcmp( value, p, len * sizeof(WCHAR) ) &&
6882 (!p[len] || p[len] == ';'))
6883 {
6884 found = 1;
6885 break;
6886 }
6887 if (!*q) break;
6888 p = ++q;
6889 }
6890
6891 if (found)
6892 {
6893 TRACE("string already set\n");
6894 goto done;
6895 }
6896
6897 size = (len_value + 1 + lstrlenW( data ) + 1) * sizeof(WCHAR);
6898 if (!(p = newval = msi_alloc( size )))
6899 {
6900 res = ERROR_OUTOFMEMORY;
6901 goto done;
6902 }
6903
6904 if (flags & ENV_MOD_PREFIX)
6905 {
6906 memcpy( newval, value, len_value * sizeof(WCHAR) );
6907 newval[len_value] = ';';
6908 p = newval + len_value + 1;
6909 action |= 0x80000000;
6910 }
6911
6912 lstrcpyW( p, data );
6913
6914 if (flags & ENV_MOD_APPEND)
6915 {
6916 p += lstrlenW( data );
6917 *p++ = ';';
6918 memcpy( p, value, (len_value + 1) * sizeof(WCHAR) );
6919 action |= 0x40000000;
6920 }
6921 }
6922 TRACE("setting %s to %s\n", debugstr_w(name), debugstr_w(newval));
6923 res = RegSetValueExW( env, name, 0, type, (BYTE *)newval, size );
6924 if (res)
6925 {
6926 WARN("Failed to set %s to %s (%d)\n", debugstr_w(name), debugstr_w(newval), res);
6927 }
6928
6929 done:
6930 uirow = MSI_CreateRecord( 3 );
6931 MSI_RecordSetStringW( uirow, 1, name );
6932 MSI_RecordSetStringW( uirow, 2, newval );
6933 MSI_RecordSetInteger( uirow, 3, action );
6934 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
6935 msiobj_release( &uirow->hdr );
6936
6937 if (env) RegCloseKey(env);
6938 msi_free(deformatted);
6939 msi_free(data);
6940 msi_free(newval);
6941 return res;
6942 }
6943
6944 static UINT ACTION_WriteEnvironmentStrings( MSIPACKAGE *package )
6945 {
6946 MSIQUERY *view;
6947 UINT rc;
6948
6949 if (package->script == SCRIPT_NONE)
6950 return msi_schedule_action(package, SCRIPT_INSTALL, L"WriteEnvironmentStrings");
6951
6952 rc = MSI_DatabaseOpenViewW(package->db, L"SELECT * FROM `Environment`", &view);
6953 if (rc != ERROR_SUCCESS)
6954 return ERROR_SUCCESS;
6955
6956 rc = MSI_IterateRecords(view, NULL, ITERATE_WriteEnvironmentString, package);
6957 msiobj_release(&view->hdr);
6958 return rc;
6959 }
6960
6961 static UINT ITERATE_RemoveEnvironmentString( MSIRECORD *rec, LPVOID param )
6962 {
6963 MSIPACKAGE *package = param;
6964 LPCWSTR name, value, component;
6965 WCHAR *p, *q, *deformatted = NULL, *new_value = NULL;
6966 DWORD flags, type, size, len, len_value = 0, len_new_value;
6967 HKEY env;
6968 MSICOMPONENT *comp;
6969 MSIRECORD *uirow;
6970 int action = 0;
6971 LONG res;
6972 UINT r;
6973
6974 component = MSI_RecordGetString( rec, 4 );
6975 comp = msi_get_loaded_component( package, component );
6976 if (!comp)
6977 return ERROR_SUCCESS;
6978
6979 comp->Action = msi_get_component_action( package, comp );
6980 if (comp->Action != INSTALLSTATE_ABSENT)
6981 {
6982 TRACE("component not scheduled for removal %s\n", debugstr_w(component));
6983 return ERROR_SUCCESS;
6984 }
6985 name = MSI_RecordGetString( rec, 2 );
6986 value = MSI_RecordGetString( rec, 3 );
6987
6988 TRACE("name %s value %s\n", debugstr_w(name), debugstr_w(value));
6989
6990 r = env_parse_flags( &name, &value, &flags );
6991 if (r != ERROR_SUCCESS)
6992 return r;
6993
6994 if (!(flags & ENV_ACT_REMOVE))
6995 {
6996 TRACE("Environment variable %s not marked for removal\n", debugstr_w(name));
6997 return ERROR_SUCCESS;
6998 }
6999
7000 if (value && !deformat_string( package, value, &deformatted ))
7001 return ERROR_OUTOFMEMORY;
7002
7003 if ((value = deformatted))
7004 {
7005 if (flags & ENV_MOD_PREFIX)
7006 {
7007 p = wcschr( value, ';' );
7008 len_value = p - value;
7009 }
7010 else if (flags & ENV_MOD_APPEND)
7011 {
7012 value = wcschr( value, ';' ) + 1;
7013 len_value = lstrlenW( value );
7014 }
7015 else len_value = lstrlenW( value );
7016 }
7017
7018 r = open_env_key( flags, &env );
7019 if (r != ERROR_SUCCESS)
7020 {
7021 r = ERROR_SUCCESS;
7022 goto done;
7023 }
7024
7025 if (flags & ENV_MOD_MACHINE)
7026 action |= 0x20000000;
7027
7028 size = 0;
7029 type = REG_SZ;
7030 res = RegQueryValueExW( env, name, NULL, &type, NULL, &size );
7031 if (res != ERROR_SUCCESS || (type != REG_SZ && type != REG_EXPAND_SZ))
7032 goto done;
7033
7034 if (!(new_value = msi_alloc( size ))) goto done;
7035
7036 res = RegQueryValueExW( env, name, NULL, &type, (BYTE *)new_value, &size );
7037 if (res != ERROR_SUCCESS)
7038 goto done;
7039
7040 len_new_value = size / sizeof(WCHAR) - 1;
7041 p = q = new_value;
7042 for (;;)
7043 {
7044 while (*q && *q != ';') q++;
7045 len = q - p;
7046 if (value && len == len_value && !memcmp( value, p, len * sizeof(WCHAR) ))
7047 {
7048 if (*q == ';') q++;
7049 memmove( p, q, (len_new_value - (q - new_value) + 1) * sizeof(WCHAR) );
7050 break;
7051 }
7052 if (!*q) break;
7053 p = ++q;
7054 }
7055
7056 if (!new_value[0] || !value)
7057 {
7058 TRACE("removing %s\n", debugstr_w(name));
7059 res = RegDeleteValueW( env, name );
7060 if (res != ERROR_SUCCESS)
7061 WARN("failed to delete value %s (%d)\n", debugstr_w(name), res);
7062 }
7063 else
7064 {
7065 TRACE("setting %s to %s\n", debugstr_w(name), debugstr_w(new_value));
7066 size = (lstrlenW( new_value ) + 1) * sizeof(WCHAR);
7067 res = RegSetValueExW( env, name, 0, type, (BYTE *)new_value, size );
7068 if (res != ERROR_SUCCESS)
7069 WARN("failed to set %s to %s (%d)\n", debugstr_w(name), debugstr_w(new_value), res);
7070 }
7071
7072 done:
7073 uirow = MSI_CreateRecord( 3 );
7074 MSI_RecordSetStringW( uirow, 1, name );
7075 MSI_RecordSetStringW( uirow, 2, value );
7076 MSI_RecordSetInteger( uirow, 3, action );
7077 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
7078 msiobj_release( &uirow->hdr );
7079
7080 if (env) RegCloseKey( env );
7081 msi_free( deformatted );
7082 msi_free( new_value );
7083 return r;
7084 }
7085
7086 static UINT ACTION_RemoveEnvironmentStrings( MSIPACKAGE *package )
7087 {
7088 MSIQUERY *view;
7089 UINT rc;
7090
7091 if (package->script == SCRIPT_NONE)
7092 return msi_schedule_action(package, SCRIPT_INSTALL, L"RemoveEnvironmentStrings");
7093
7094 rc = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Environment`", &view );
7095 if (rc != ERROR_SUCCESS)
7096 return ERROR_SUCCESS;
7097
7098 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveEnvironmentString, package );
7099 msiobj_release( &view->hdr );
7100 return rc;
7101 }
7102
7103 UINT msi_validate_product_id( MSIPACKAGE *package )
7104 {
7105 LPWSTR key, template, id;
7106 UINT r = ERROR_SUCCESS;
7107
7108 id = msi_dup_property( package->db, L"ProductID" );
7109 if (id)
7110 {
7111 msi_free( id );
7112 return ERROR_SUCCESS;
7113 }
7114 template = msi_dup_property( package->db, L"PIDTemplate" );
7115 key = msi_dup_property( package->db, L"PIDKEY" );
7116 if (key && template)
7117 {
7118 FIXME( "partial stub: template %s key %s\n", debugstr_w(template), debugstr_w(key) );
7119 r = msi_set_property( package->db, L"ProductID", key, -1 );
7120 }
7121 msi_free( template );
7122 msi_free( key );
7123 return r;
7124 }
7125
7126 static UINT ACTION_ValidateProductID( MSIPACKAGE *package )
7127 {
7128 return msi_validate_product_id( package );
7129 }
7130
7131 static UINT ACTION_ScheduleReboot( MSIPACKAGE *package )
7132 {
7133 TRACE("\n");
7134 package->need_reboot_at_end = 1;
7135 return ERROR_SUCCESS;
7136 }
7137
7138 static UINT ACTION_AllocateRegistrySpace( MSIPACKAGE *package )
7139 {
7140 MSIRECORD *uirow;
7141 int space = msi_get_property_int( package->db, L"AVAILABLEFREEREG", 0 );
7142
7143 TRACE("%p %d kilobytes\n", package, space);
7144
7145 uirow = MSI_CreateRecord( 1 );
7146 MSI_RecordSetInteger( uirow, 1, space );
7147 MSI_ProcessMessage(package, INSTALLMESSAGE_ACTIONDATA, uirow);
7148 msiobj_release( &uirow->hdr );
7149
7150 return ERROR_SUCCESS;
7151 }
7152
7153 static UINT ACTION_DisableRollback( MSIPACKAGE *package )
7154 {
7155 TRACE("%p\n", package);
7156
7157 msi_set_property( package->db, L"RollbackDisabled", L"1", -1 );
7158 return ERROR_SUCCESS;
7159 }
7160
7161 static UINT ACTION_InstallAdminPackage( MSIPACKAGE *package )
7162 {
7163 FIXME("%p\n", package);
7164 return ERROR_SUCCESS;
7165 }
7166
7167 static UINT ACTION_SetODBCFolders( MSIPACKAGE *package )
7168 {
7169 MSIQUERY *view;
7170 UINT r, count;
7171
7172 r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `ODBCDriver`", &view );
7173 if (r == ERROR_SUCCESS)
7174 {
7175 count = 0;
7176 r = MSI_IterateRecords( view, &count, NULL, package );
7177 msiobj_release( &view->hdr );
7178 if (r != ERROR_SUCCESS)
7179 return r;
7180 if (count) FIXME("ignored %u rows in ODBCDriver table\n", count);
7181 }
7182 r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `ODBCTranslator`", &view );
7183 if (r == ERROR_SUCCESS)
7184 {
7185 count = 0;
7186 r = MSI_IterateRecords( view, &count, NULL, package );
7187 msiobj_release( &view->hdr );
7188 if (r != ERROR_SUCCESS)
7189 return r;
7190 if (count) FIXME("ignored %u rows in ODBCTranslator table\n", count);
7191 }
7192 return ERROR_SUCCESS;
7193 }
7194
7195 static UINT ITERATE_RemoveExistingProducts( MSIRECORD *rec, LPVOID param )
7196 {
7197 MSIPACKAGE *package = param;
7198 const WCHAR *property = MSI_RecordGetString( rec, 7 );
7199 int attrs = MSI_RecordGetInteger( rec, 5 );
7200 UINT len = ARRAY_SIZE( L"msiexec /qn /i %s REMOVE=%s" );
7201 WCHAR *product, *features, *cmd;
7202 STARTUPINFOW si;
7203 PROCESS_INFORMATION info;
7204 BOOL ret;
7205
7206 if (attrs & msidbUpgradeAttributesOnlyDetect) return ERROR_SUCCESS;
7207 if (!(product = msi_dup_property( package->db, property ))) return ERROR_SUCCESS;
7208
7209 deformat_string( package, MSI_RecordGetString( rec, 6 ), &features );
7210
7211 len += lstrlenW( product );
7212 if (features)
7213 len += lstrlenW( features );
7214 else
7215 len += ARRAY_SIZE( L"ALL" );
7216
7217 if (!(cmd = msi_alloc( len * sizeof(WCHAR) )))
7218 {
7219 msi_free( product );
7220 msi_free( features );
7221 return ERROR_OUTOFMEMORY;
7222 }
7223 swprintf( cmd, len, L"msiexec /qn /i %s REMOVE=%s", product, features ? features : L"ALL" );
7224 msi_free( product );
7225 msi_free( features );
7226
7227 memset( &si, 0, sizeof(STARTUPINFOW) );
7228 ret = CreateProcessW( NULL, cmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &info );
7229 msi_free( cmd );
7230 if (!ret) return GetLastError();
7231 CloseHandle( info.hThread );
7232
7233 WaitForSingleObject( info.hProcess, INFINITE );
7234 CloseHandle( info.hProcess );
7235 return ERROR_SUCCESS;
7236 }
7237
7238 static UINT ACTION_RemoveExistingProducts( MSIPACKAGE *package )
7239 {
7240 MSIQUERY *view;
7241 UINT r;
7242
7243 r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Upgrade`", &view );
7244 if (r == ERROR_SUCCESS)
7245 {
7246 r = MSI_IterateRecords( view, NULL, ITERATE_RemoveExistingProducts, package );
7247 msiobj_release( &view->hdr );
7248 if (r != ERROR_SUCCESS)
7249 return r;
7250 }
7251 return ERROR_SUCCESS;
7252 }
7253
7254 static UINT ITERATE_MigrateFeatureStates( MSIRECORD *rec, LPVOID param )
7255 {
7256 MSIPACKAGE *package = param;
7257 int attributes = MSI_RecordGetInteger( rec, 5 );
7258
7259 if (attributes & msidbUpgradeAttributesMigrateFeatures)
7260 {
7261 const WCHAR *upgrade_code = MSI_RecordGetString( rec, 1 );
7262 const WCHAR *version_min = MSI_RecordGetString( rec, 2 );
7263 const WCHAR *version_max = MSI_RecordGetString( rec, 3 );
7264 const WCHAR *language = MSI_RecordGetString( rec, 4 );
7265 HKEY hkey;
7266 UINT r;
7267
7268 if (package->Context == MSIINSTALLCONTEXT_MACHINE)
7269 {
7270 r = MSIREG_OpenClassesUpgradeCodesKey( upgrade_code, &hkey, FALSE );
7271 if (r != ERROR_SUCCESS)
7272 return ERROR_SUCCESS;
7273 }
7274 else
7275 {
7276 r = MSIREG_OpenUserUpgradeCodesKey( upgrade_code, &hkey, FALSE );
7277 if (r != ERROR_SUCCESS)
7278 return ERROR_SUCCESS;
7279 }
7280 RegCloseKey( hkey );
7281
7282 FIXME("migrate feature states from %s version min %s version max %s language %s\n",
7283 debugstr_w(upgrade_code), debugstr_w(version_min),
7284 debugstr_w(version_max), debugstr_w(language));
7285 }
7286 return ERROR_SUCCESS;
7287 }
7288
7289 static UINT ACTION_MigrateFeatureStates( MSIPACKAGE *package )
7290 {
7291 MSIQUERY *view;
7292 UINT r;
7293
7294 if (msi_get_property_int( package->db, L"Installed", 0 ))
7295 {
7296 TRACE("product is installed, skipping action\n");
7297 return ERROR_SUCCESS;
7298 }
7299 if (msi_get_property_int( package->db, L"Preselected", 0 ))
7300 {
7301 TRACE("Preselected property is set, not migrating feature states\n");
7302 return ERROR_SUCCESS;
7303 }
7304 r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `Upgrade`", &view );
7305 if (r == ERROR_SUCCESS)
7306 {
7307 r = MSI_IterateRecords( view, NULL, ITERATE_MigrateFeatureStates, package );
7308 msiobj_release( &view->hdr );
7309 if (r != ERROR_SUCCESS)
7310 return r;
7311 }
7312 return ERROR_SUCCESS;
7313 }
7314
7315 static BOOL msi_bind_image( MSIPACKAGE *package, const char *filename, const char *path )
7316 {
7317 BOOL ret;
7318 msi_disable_fs_redirection( package );
7319 ret = BindImage( filename, path, NULL );
7320 msi_revert_fs_redirection( package );
7321 return ret;
7322 }
7323
7324 static void bind_image( MSIPACKAGE *package, const char *filename, const char *path )
7325 {
7326 if (!msi_bind_image( package, filename, path ))
7327 {
7328 WARN("failed to bind image %u\n", GetLastError());
7329 }
7330 }
7331
7332 static UINT ITERATE_BindImage( MSIRECORD *rec, LPVOID param )
7333 {
7334 UINT i;
7335 MSIFILE *file;
7336 MSIPACKAGE *package = param;
7337 const WCHAR *key = MSI_RecordGetString( rec, 1 );
7338 const WCHAR *paths = MSI_RecordGetString( rec, 2 );
7339 char *filenameA, *pathA;
7340 WCHAR *pathW, **path_list;
7341
7342 if (!(file = msi_get_loaded_file( package, key )))
7343 {
7344 WARN("file %s not found\n", debugstr_w(key));
7345 return ERROR_SUCCESS;
7346 }
7347 if (!(filenameA = strdupWtoA( file->TargetPath ))) return ERROR_SUCCESS;
7348
7349 path_list = msi_split_string( paths, ';' );
7350 if (!path_list) bind_image( package, filenameA, NULL );
7351 else
7352 {
7353 for (i = 0; path_list[i] && path_list[i][0]; i++)
7354 {
7355 deformat_string( package, path_list[i], &pathW );
7356 if ((pathA = strdupWtoA( pathW )))
7357 {
7358 bind_image( package, filenameA, pathA );
7359 msi_free( pathA );
7360 }
7361 msi_free( pathW );
7362 }
7363 }
7364 msi_free( path_list );
7365 msi_free( filenameA );
7366
7367 return ERROR_SUCCESS;
7368 }
7369
7370 static UINT ACTION_BindImage( MSIPACKAGE *package )
7371 {
7372 MSIQUERY *view;
7373 UINT r;
7374
7375 r = MSI_DatabaseOpenViewW( package->db, L"SELECT * FROM `BindImage`", &view );
7376 if (r == ERROR_SUCCESS)
7377 {
7378 MSI_IterateRecords( view, NULL, ITERATE_BindImage, package );
7379 msiobj_release( &view->hdr );
7380 }
7381 return ERROR_SUCCESS;
7382 }
7383
7384 static UINT msi_unimplemented_action_stub( MSIPACKAGE *package, LPCSTR action, LPCWSTR table )
7385 {
7386 MSIQUERY *view;
7387 DWORD count = 0;
7388 UINT r;
7389
7390 r = MSI_OpenQuery( package->db, &view, L"SELECT * FROM `%s`", table );
7391 if (r == ERROR_SUCCESS)
7392 {
7393 r = MSI_IterateRecords(view, &count, NULL, package);
7394 msiobj_release(&view->hdr);
7395 if (r != ERROR_SUCCESS)
7396 return r;
7397 }
7398 if (count) FIXME("%s: ignored %u rows from %s\n", action, count, debugstr_w(table));
7399 return ERROR_SUCCESS;
7400 }
7401
7402 static UINT ACTION_IsolateComponents( MSIPACKAGE *package )
7403 {
7404 return msi_unimplemented_action_stub( package, "IsolateComponents", L"IsolateComponent" );
7405 }
7406
7407 static UINT ACTION_RMCCPSearch( MSIPACKAGE *package )
7408 {
7409 return msi_unimplemented_action_stub( package, "RMCCPSearch", L"CCPSearch" );
7410 }
7411
7412 static UINT ACTION_RegisterComPlus( MSIPACKAGE *package )
7413 {
7414 return msi_unimplemented_action_stub( package, "RegisterComPlus", L"Complus" );
7415 }
7416
7417 static UINT ACTION_UnregisterComPlus( MSIPACKAGE *package )
7418 {
7419 return msi_unimplemented_action_stub( package, "UnregisterComPlus", L"Complus" );
7420 }
7421
7422 static UINT ACTION_InstallSFPCatalogFile( MSIPACKAGE *package )
7423 {
7424 return msi_unimplemented_action_stub( package, "InstallSFPCatalogFile", L"SFPCatalog" );
7425 }
7426
7427 static const struct
7428 {
7429 const WCHAR *action;
7430 const UINT description;
7431 const UINT template;
7432 UINT (*handler)(MSIPACKAGE *);
7433 const WCHAR *action_rollback;
7434 }
7435 StandardActions[] =
7436 {
7437 { L"AllocateRegistrySpace", IDS_DESC_ALLOCATEREGISTRYSPACE, IDS_TEMP_ALLOCATEREGISTRYSPACE, ACTION_AllocateRegistrySpace, NULL },
7438 { L"AppSearch", IDS_DESC_APPSEARCH, IDS_TEMP_APPSEARCH, ACTION_AppSearch, NULL },
7439 { L"BindImage", IDS_DESC_BINDIMAGE, IDS_TEMP_BINDIMAGE, ACTION_BindImage, NULL },
7440 { L"CCPSearch", IDS_DESC_CCPSEARCH, 0, ACTION_CCPSearch, NULL },
7441 { L"CostFinalize", IDS_DESC_COSTFINALIZE, 0, ACTION_CostFinalize, NULL },
7442 { L"CostInitialize", IDS_DESC_COSTINITIALIZE, 0, ACTION_CostInitialize, NULL },
7443 { L"CreateFolders", IDS_DESC_CREATEFOLDERS, IDS_TEMP_CREATEFOLDERS, ACTION_CreateFolders, L"RemoveFolders" },
7444 { L"CreateShortcuts", IDS_DESC_CREATESHORTCUTS, IDS_TEMP_CREATESHORTCUTS, ACTION_CreateShortcuts, L"RemoveShortcuts" },
7445 { L"DeleteServices", IDS_DESC_DELETESERVICES, IDS_TEMP_DELETESERVICES, ACTION_DeleteServices, L"InstallServices" },
7446 { L"DisableRollback", 0, 0, ACTION_DisableRollback, NULL },
7447 { L"DuplicateFiles", IDS_DESC_DUPLICATEFILES, IDS_TEMP_DUPLICATEFILES, ACTION_DuplicateFiles, L"RemoveDuplicateFiles" },
7448 { L"ExecuteAction", 0, 0, ACTION_ExecuteAction, NULL },
7449 { L"FileCost", IDS_DESC_FILECOST, 0, ACTION_FileCost, NULL },
7450 { L"FindRelatedProducts", IDS_DESC_FINDRELATEDPRODUCTS, IDS_TEMP_FINDRELATEDPRODUCTS, ACTION_FindRelatedProducts, NULL },
7451 { L"ForceReboot", 0, 0, ACTION_ForceReboot, NULL },
7452 { L"InstallAdminPackage", IDS_DESC_INSTALLADMINPACKAGE, IDS_TEMP_INSTALLADMINPACKAGE, ACTION_InstallAdminPackage, NULL },
7453 { L"InstallExecute", 0, 0, ACTION_InstallExecute, NULL },
7454 { L"InstallExecuteAgain", 0, 0, ACTION_InstallExecute, NULL },
7455 { L"InstallFiles", IDS_DESC_INSTALLFILES, IDS_TEMP_INSTALLFILES, ACTION_InstallFiles, L"RemoveFiles" },
7456 { L"InstallFinalize", 0, 0, ACTION_InstallFinalize, NULL },
7457 { L"InstallInitialize", 0, 0, ACTION_InstallInitialize, NULL },
7458 { L"InstallODBC", IDS_DESC_INSTALLODBC, 0, ACTION_InstallODBC, L"RemoveODBC" },
7459 { L"InstallServices", IDS_DESC_INSTALLSERVICES, IDS_TEMP_INSTALLSERVICES, ACTION_InstallServices, L"DeleteServices" },
7460 { L"InstallSFPCatalogFile", IDS_DESC_INSTALLSFPCATALOGFILE, IDS_TEMP_INSTALLSFPCATALOGFILE, ACTION_InstallSFPCatalogFile, NULL },
7461 { L"InstallValidate", IDS_DESC_INSTALLVALIDATE, 0, ACTION_InstallValidate, NULL },
7462 { L"IsolateComponents", 0, 0, ACTION_IsolateComponents, NULL },
7463 { L"LaunchConditions", IDS_DESC_LAUNCHCONDITIONS, 0, ACTION_LaunchConditions, NULL },
7464 { L"MigrateFeutureStates", IDS_DESC_MIGRATEFEATURESTATES, IDS_TEMP_MIGRATEFEATURESTATES, ACTION_MigrateFeatureStates, NULL },
7465 { L"MoveFiles", IDS_DESC_MOVEFILES, IDS_TEMP_MOVEFILES, ACTION_MoveFiles, NULL },
7466 { L"MsiPublishAssemblies", IDS_DESC_MSIPUBLISHASSEMBLIES, IDS_TEMP_MSIPUBLISHASSEMBLIES, ACTION_MsiPublishAssemblies, L"MsiUnpublishAssemblies" },
7467 { L"MsiUnpublishAssemblies", IDS_DESC_MSIUNPUBLISHASSEMBLIES, IDS_TEMP_MSIUNPUBLISHASSEMBLIES, ACTION_MsiUnpublishAssemblies, L"MsiPublishAssemblies" },
7468 { L"PatchFiles", IDS_DESC_PATCHFILES, IDS_TEMP_PATCHFILES, ACTION_PatchFiles, NULL },
7469 { L"ProcessComponents", IDS_DESC_PROCESSCOMPONENTS, 0, ACTION_ProcessComponents, L"ProcessComponents" },
7470 { L"PublishComponents", IDS_DESC_PUBLISHCOMPONENTS, IDS_TEMP_PUBLISHCOMPONENTS, ACTION_PublishComponents, L"UnpublishComponents" },
7471 { L"PublishFeatures", IDS_DESC_PUBLISHFEATURES, IDS_TEMP_PUBLISHFEATURES, ACTION_PublishFeatures, L"UnpublishFeatures" },
7472 { L"PublishProduct", IDS_DESC_PUBLISHPRODUCT, 0, ACTION_PublishProduct, L"UnpublishProduct" },
7473 { L"RegisterClassInfo", IDS_DESC_REGISTERCLASSINFO, IDS_TEMP_REGISTERCLASSINFO, ACTION_RegisterClassInfo, L"UnregisterClassInfo" },
7474 { L"RegisterComPlus", IDS_DESC_REGISTERCOMPLUS, IDS_TEMP_REGISTERCOMPLUS, ACTION_RegisterComPlus, L"UnregisterComPlus" },
7475 { L"RegisterExtensionInfo", IDS_DESC_REGISTEREXTENSIONINFO, 0, ACTION_RegisterExtensionInfo, L"UnregisterExtensionInfo" },
7476 { L"RegisterFonts", IDS_DESC_REGISTERFONTS, IDS_TEMP_REGISTERFONTS, ACTION_RegisterFonts, L"UnregisterFonts" },
7477 { L"RegisterMIMEInfo", IDS_DESC_REGISTERMIMEINFO, IDS_TEMP_REGISTERMIMEINFO, ACTION_RegisterMIMEInfo, L"UnregisterMIMEInfo" },
7478 { L"RegisterProduct", IDS_DESC_REGISTERPRODUCT, 0, ACTION_RegisterProduct, NULL },
7479 { L"RegisterProgIdInfo", IDS_DESC_REGISTERPROGIDINFO, IDS_TEMP_REGISTERPROGIDINFO, ACTION_RegisterProgIdInfo, L"UnregisterProgIdInfo" },
7480 { L"RegisterTypeLibraries", IDS_DESC_REGISTERTYPELIBRARIES, IDS_TEMP_REGISTERTYPELIBRARIES, ACTION_RegisterTypeLibraries, L"UnregisterTypeLibraries" },
7481 { L"RegisterUser", IDS_DESC_REGISTERUSER, 0, ACTION_RegisterUser, NULL },
7482 { L"RemoveDuplicateFiles", IDS_DESC_REMOVEDUPLICATEFILES, IDS_TEMP_REMOVEDUPLICATEFILES, ACTION_RemoveDuplicateFiles, L"DuplicateFiles" },
7483 { L"RemoveEnvironmentStrings", IDS_DESC_REMOVEENVIRONMENTSTRINGS, IDS_TEMP_REMOVEENVIRONMENTSTRINGS, ACTION_RemoveEnvironmentStrings, L"WriteEnvironmentStrings" },
7484 { L"RemoveExistingProducts", IDS_DESC_REMOVEEXISTINGPRODUCTS, IDS_TEMP_REMOVEEXISTINGPRODUCTS, ACTION_RemoveExistingProducts, NULL },
7485 { L"RemoveFiles", IDS_DESC_REMOVEFILES, IDS_TEMP_REMOVEFILES, ACTION_RemoveFiles, L"InstallFiles" },
7486 { L"RemoveFolders", IDS_DESC_REMOVEFOLDERS, IDS_TEMP_REMOVEFOLDERS, ACTION_RemoveFolders, L"CreateFolders" },
7487 { L"RemoveIniValues", IDS_DESC_REMOVEINIVALUES, IDS_TEMP_REMOVEINIVALUES, ACTION_RemoveIniValues, L"WriteIniValues" },
7488 { L"RemoveODBC", IDS_DESC_REMOVEODBC, 0, ACTION_RemoveODBC, L"InstallODBC" },
7489 { L"RemoveRegistryValues", IDS_DESC_REMOVEREGISTRYVALUES, IDS_TEMP_REMOVEREGISTRYVALUES, ACTION_RemoveRegistryValues, L"WriteRegistryValues" },
7490 { L"RemoveShortcuts", IDS_DESC_REMOVESHORTCUTS, IDS_TEMP_REMOVESHORTCUTS, ACTION_RemoveShortcuts, L"CreateShortcuts" },
7491 { L"ResolveSource", 0, 0, ACTION_ResolveSource, NULL },
7492 { L"RMCCPSearch", IDS_DESC_RMCCPSEARCH, 0, ACTION_RMCCPSearch, NULL },
7493 { L"ScheduleReboot", 0, 0, ACTION_ScheduleReboot, NULL },
7494 { L"SelfRegModules", IDS_DESC_SELFREGMODULES, IDS_TEMP_SELFREGMODULES, ACTION_SelfRegModules, L"SelfUnregModules" },
7495 { L"SelfUnregModules", IDS_DESC_SELFUNREGMODULES, IDS_TEMP_SELFUNREGMODULES, ACTION_SelfUnregModules, L"SelfRegModules" },
7496 { L"SetODBCFolders", IDS_DESC_SETODBCFOLDERS, 0, ACTION_SetODBCFolders, NULL },
7497 { L"StartServices", IDS_DESC_STARTSERVICES, IDS_TEMP_STARTSERVICES, ACTION_StartServices, L"StopServices" },
7498 { L"StopServices", IDS_DESC_STOPSERVICES, IDS_TEMP_STOPSERVICES, ACTION_StopServices, L"StartServices" },
7499 { L"UnpublishComponents", IDS_DESC_UNPUBLISHCOMPONENTS, IDS_TEMP_UNPUBLISHCOMPONENTS, ACTION_UnpublishComponents, L"PublishComponents" },
7500 { L"UnpublishFeatures", IDS_DESC_UNPUBLISHFEATURES, IDS_TEMP_UNPUBLISHFEATURES, ACTION_UnpublishFeatures, L"PublishFeatures" },
7501 { L"UnpublishProduct", IDS_DESC_UNPUBLISHPRODUCT, 0, ACTION_UnpublishProduct, NULL }, /* for rollback only */
7502 { L"UnregisterClassInfo", IDS_DESC_UNREGISTERCLASSINFO, IDS_TEMP_UNREGISTERCLASSINFO, ACTION_UnregisterClassInfo, L"RegisterClassInfo" },
7503 { L"UnregisterComPlus", IDS_DESC_UNREGISTERCOMPLUS, IDS_TEMP_UNREGISTERCOMPLUS, ACTION_UnregisterComPlus, L"RegisterComPlus" },
7504 { L"UnregisterExtensionInfo", IDS_DESC_UNREGISTEREXTENSIONINFO, IDS_TEMP_UNREGISTEREXTENSIONINFO, ACTION_UnregisterExtensionInfo, L"RegisterExtensionInfo" },
7505 { L"UnregisterFonts", IDS_DESC_UNREGISTERFONTS, IDS_TEMP_UNREGISTERFONTS, ACTION_UnregisterFonts, L"RegisterFonts" },
7506 { L"UnregisterMIMEInfo", IDS_DESC_UNREGISTERMIMEINFO, IDS_TEMP_UNREGISTERMIMEINFO, ACTION_UnregisterMIMEInfo, L"RegisterMIMEInfo" },
7507 { L"UnregisterProgIdInfo", IDS_DESC_UNREGISTERPROGIDINFO, IDS_TEMP_UNREGISTERPROGIDINFO, ACTION_UnregisterProgIdInfo, L"RegisterProgIdInfo" },
7508 { L"UnregisterTypeLibraries", IDS_DESC_UNREGISTERTYPELIBRARIES, IDS_TEMP_UNREGISTERTYPELIBRARIES, ACTION_UnregisterTypeLibraries, L"RegisterTypeLibraries" },
7509 { L"ValidateProductID", 0, 0, ACTION_ValidateProductID, NULL },
7510 { L"WriteEnvironmentStrings", IDS_DESC_WRITEENVIRONMENTSTRINGS, IDS_TEMP_WRITEENVIRONMENTSTRINGS, ACTION_WriteEnvironmentStrings, L"RemoveEnvironmentStrings" },
7511 { L"WriteIniValues", IDS_DESC_WRITEINIVALUES, IDS_TEMP_WRITEINIVALUES, ACTION_WriteIniValues, L"RemoveIniValues" },
7512 { L"WriteRegistryValues", IDS_DESC_WRITEREGISTRYVALUES, IDS_TEMP_WRITEREGISTRYVALUES, ACTION_WriteRegistryValues, L"RemoveRegistryValues" },
7513 { L"INSTALL", 0, 0, ACTION_INSTALL, NULL },
7514 { 0 }
7515 };
7516
7517 static UINT ACTION_HandleStandardAction(MSIPACKAGE *package, LPCWSTR action)
7518 {
7519 UINT rc = ERROR_FUNCTION_NOT_CALLED;
7520 UINT i;
7521
7522 i = 0;
7523 while (StandardActions[i].action != NULL)
7524 {
7525 if (!wcscmp( StandardActions[i].action, action ))
7526 {
7527 WCHAR description[100] = {0}, template[100] = {0};
7528
7529 if (StandardActions[i].description != 0)
7530 LoadStringW(msi_hInstance, StandardActions[i].description, (LPWSTR)&description, 100);
7531 if (StandardActions[i].template != 0)
7532 LoadStringW(msi_hInstance, StandardActions[i].template, (LPWSTR)&template, 100);
7533
7534 ui_actionstart(package, action, description, template);
7535 if (StandardActions[i].handler)
7536 {
7537 ui_actioninfo( package, action, TRUE, 0 );
7538 rc = StandardActions[i].handler( package );
7539 ui_actioninfo( package, action, FALSE, !rc );
7540
7541 if (StandardActions[i].action_rollback && !package->need_rollback)
7542 {
7543 TRACE("scheduling rollback action\n");
7544 msi_schedule_action( package, SCRIPT_ROLLBACK, StandardActions[i].action_rollback );
7545 }
7546 }
7547 else
7548 {
7549 FIXME("unhandled standard action %s\n", debugstr_w(action));
7550 rc = ERROR_SUCCESS;
7551 }
7552 break;
7553 }
7554 i++;
7555 }
7556
7557 return rc;
7558 }
7559
7560 UINT ACTION_PerformAction(MSIPACKAGE *package, const WCHAR *action)
7561 {
7562 UINT rc;
7563
7564 TRACE("Performing action (%s)\n", debugstr_w(action));
7565
7566 package->action_progress_increment = 0;
7567 rc = ACTION_HandleStandardAction(package, action);
7568
7569 if (rc == ERROR_FUNCTION_NOT_CALLED)
7570 rc = ACTION_HandleCustomAction(package, action);
7571
7572 if (rc == ERROR_FUNCTION_NOT_CALLED)
7573 WARN("unhandled msi action %s\n", debugstr_w(action));
7574
7575 return rc;
7576 }
7577
7578 static UINT ACTION_PerformActionSequence(MSIPACKAGE *package, UINT seq)
7579 {
7580 UINT rc = ERROR_SUCCESS;
7581 MSIRECORD *row;
7582
7583 if (needs_ui_sequence(package))
7584 row = MSI_QueryGetRecord(package->db, L"SELECT * FROM `InstallUISequence` WHERE `Sequence` = %d", seq);
7585 else
7586 row = MSI_QueryGetRecord(package->db, L"SELECT * FROM `InstallExecuteSequence` WHERE `Sequence` = %d", seq);
7587
7588 if (row)
7589 {
7590 LPCWSTR action, cond;
7591
7592 TRACE("Running the actions\n");
7593
7594 /* check conditions */
7595 cond = MSI_RecordGetString(row, 2);
7596
7597 /* this is a hack to skip errors in the condition code */
7598 if (MSI_EvaluateConditionW(package, cond) == MSICONDITION_FALSE)
7599 {
7600 msiobj_release(&row->hdr);
7601 return ERROR_SUCCESS;
7602 }
7603
7604 action = MSI_RecordGetString(row, 1);
7605 if (!action)
7606 {
7607 ERR("failed to fetch action\n");
7608 msiobj_release(&row->hdr);
7609 return ERROR_FUNCTION_FAILED;
7610 }
7611
7612 rc = ACTION_PerformAction(package, action);
7613
7614 msiobj_release(&row->hdr);
7615 }
7616
7617 return rc;
7618 }
7619
7620 /****************************************************
7621 * TOP level entry points
7622 *****************************************************/
7623
7624 UINT MSI_InstallPackage( MSIPACKAGE *package, LPCWSTR szPackagePath,
7625 LPCWSTR szCommandLine )
7626 {
7627 WCHAR *reinstall = NULL, *productcode, *action;
7628 UINT rc;
7629 DWORD len = 0;
7630
7631 if (szPackagePath)
7632 {
7633 LPWSTR p, dir;
7634 LPCWSTR file;
7635
7636 dir = strdupW(szPackagePath);
7637 p = wcsrchr(dir, '\\');
7638 if (p)
7639 {
7640 *(++p) = 0;
7641 file = szPackagePath + (p - dir);
7642 }
7643 else
7644 {
7645 msi_free(dir);
7646 dir = msi_alloc(MAX_PATH * sizeof(WCHAR));
7647 GetCurrentDirectoryW(MAX_PATH, dir);
7648 lstrcatW(dir, L"\\");
7649 file = szPackagePath;
7650 }
7651
7652 msi_free( package->PackagePath );
7653 package->PackagePath = msi_alloc((lstrlenW(dir) + lstrlenW(file) + 1) * sizeof(WCHAR));
7654 if (!package->PackagePath)
7655 {
7656 msi_free(dir);
7657 return ERROR_OUTOFMEMORY;
7658 }
7659
7660 lstrcpyW(package->PackagePath, dir);
7661 lstrcatW(package->PackagePath, file);
7662 msi_free(dir);
7663
7664 msi_set_sourcedir_props(package, FALSE);
7665 }
7666
7667 rc = msi_parse_command_line( package, szCommandLine, FALSE );
7668 if (rc != ERROR_SUCCESS)
7669 return rc;
7670
7671 msi_apply_transforms( package );
7672 msi_apply_patches( package );
7673
7674 if (msi_get_property( package->db, L"ACTION", NULL, &len ))
7675 msi_set_property( package->db, L"ACTION", L"INSTALL", -1 );
7676 action = msi_dup_property( package->db, L"ACTION" );
7677 CharUpperW(action);
7678
7679 msi_set_original_database_property( package->db, szPackagePath );
7680 msi_parse_command_line( package, szCommandLine, FALSE );
7681 msi_adjust_privilege_properties( package );
7682 msi_set_context( package );
7683
7684 productcode = msi_dup_property( package->db, L"ProductCode" );
7685 if (wcsicmp( productcode, package->ProductCode ))
7686 {
7687 TRACE( "product code changed %s -> %s\n", debugstr_w(package->ProductCode), debugstr_w(productcode) );
7688 msi_free( package->ProductCode );
7689 package->ProductCode = productcode;
7690 }
7691 else msi_free( productcode );
7692
7693 if (msi_get_property_int( package->db, L"DISABLEROLLBACK", 0 ))
7694 {
7695 TRACE("disabling rollback\n");
7696 msi_set_property( package->db, L"RollbackDisabled", L"1", -1 );
7697 }
7698
7699 rc = ACTION_PerformAction(package, action);
7700
7701 /* process the ending type action */
7702 if (rc == ERROR_SUCCESS)
7703 ACTION_PerformActionSequence(package, -1);
7704 else if (rc == ERROR_INSTALL_USEREXIT)
7705 ACTION_PerformActionSequence(package, -2);
7706 else if (rc == ERROR_INSTALL_SUSPEND)
7707 ACTION_PerformActionSequence(package, -4);
7708 else /* failed */
7709 {
7710 ACTION_PerformActionSequence(package, -3);
7711 if (!msi_get_property_int( package->db, L"RollbackDisabled", 0 ))
7712 {
7713 package->need_rollback = TRUE;
7714 }
7715 }
7716
7717 /* finish up running custom actions */
7718 ACTION_FinishCustomActions(package);
7719
7720 if (package->need_rollback && !(reinstall = msi_dup_property( package->db, L"REINSTALL" )))
7721 {
7722 WARN("installation failed, running rollback script\n");
7723 execute_script( package, SCRIPT_ROLLBACK );
7724 }
7725 msi_free( reinstall );
7726 msi_free( action );
7727
7728 if (rc == ERROR_SUCCESS && package->need_reboot_at_end)
7729 return ERROR_SUCCESS_REBOOT_REQUIRED;
7730
7731 return rc;
7732 }
Zebediah Figura's local tree