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