0ed9582c1793090438fd23f61e712c3674649c6c
[reactos.git] / reactos / dll / win32 / msi / files.c
1 /*
2 * Implementation of the Microsoft Installer (msi.dll)
3 *
4 * Copyright 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
22 /*
23 * Actions dealing with files These are
24 *
25 * InstallFiles
26 * DuplicateFiles
27 * MoveFiles
28 * PatchFiles (TODO)
29 * RemoveDuplicateFiles
30 * RemoveFiles
31 */
32
33 #include <stdarg.h>
34
35 #include "windef.h"
36 #include "winbase.h"
37 #include "winerror.h"
38 #include "wine/debug.h"
39 #include "fdi.h"
40 #include "msi.h"
41 #include "msidefs.h"
42 #include "msipriv.h"
43 #include "winuser.h"
44 #include "winreg.h"
45 #include "shlwapi.h"
46 #include "wine/unicode.h"
47
48 WINE_DEFAULT_DEBUG_CHANNEL(msi);
49
50 static void msi_file_update_ui( MSIPACKAGE *package, MSIFILE *f, const WCHAR *action )
51 {
52 MSIRECORD *uirow;
53
54 uirow = MSI_CreateRecord( 9 );
55 MSI_RecordSetStringW( uirow, 1, f->FileName );
56 MSI_RecordSetStringW( uirow, 9, f->Component->Directory );
57 MSI_RecordSetInteger( uirow, 6, f->FileSize );
58 ui_actiondata( package, action, uirow );
59 msiobj_release( &uirow->hdr );
60 ui_progress( package, 2, f->FileSize, 0, 0 );
61 }
62
63 static void schedule_install_files(MSIPACKAGE *package)
64 {
65 MSIFILE *file;
66
67 LIST_FOR_EACH_ENTRY(file, &package->files, MSIFILE, entry)
68 {
69 if (file->Component->ActionRequest != INSTALLSTATE_LOCAL || !file->Component->Enabled)
70 {
71 TRACE("File %s is not scheduled for install\n", debugstr_w(file->File));
72
73 ui_progress(package,2,file->FileSize,0,0);
74 file->state = msifs_skipped;
75 }
76 else
77 file->Component->Action = INSTALLSTATE_LOCAL;
78 }
79 }
80
81 static UINT copy_file(MSIFILE *file, LPWSTR source)
82 {
83 BOOL ret;
84
85 ret = CopyFileW(source, file->TargetPath, FALSE);
86 if (!ret)
87 return GetLastError();
88
89 SetFileAttributesW(file->TargetPath, FILE_ATTRIBUTE_NORMAL);
90
91 file->state = msifs_installed;
92 return ERROR_SUCCESS;
93 }
94
95 static UINT copy_install_file(MSIPACKAGE *package, MSIFILE *file, LPWSTR source)
96 {
97 UINT gle;
98
99 TRACE("Copying %s to %s\n", debugstr_w(source), debugstr_w(file->TargetPath));
100
101 gle = copy_file(file, source);
102 if (gle == ERROR_SUCCESS)
103 return gle;
104
105 if (gle == ERROR_ALREADY_EXISTS && file->state == msifs_overwrite)
106 {
107 TRACE("overwriting existing file\n");
108 return ERROR_SUCCESS;
109 }
110 else if (gle == ERROR_ACCESS_DENIED)
111 {
112 SetFileAttributesW(file->TargetPath, FILE_ATTRIBUTE_NORMAL);
113
114 gle = copy_file(file, source);
115 TRACE("Overwriting existing file: %d\n", gle);
116 }
117 if (gle == ERROR_SHARING_VIOLATION || gle == ERROR_USER_MAPPED_FILE)
118 {
119 WCHAR tmpfileW[MAX_PATH], *pathW, *p;
120 DWORD len;
121
122 TRACE("file in use, scheduling rename operation\n");
123
124 GetTempFileNameW(szBackSlash, szMsi, 0, tmpfileW);
125 len = strlenW(file->TargetPath) + strlenW(tmpfileW) + 1;
126 if (!(pathW = msi_alloc(len * sizeof(WCHAR))))
127 return ERROR_OUTOFMEMORY;
128
129 strcpyW(pathW, file->TargetPath);
130 if ((p = strrchrW(pathW, '\\'))) *p = 0;
131 strcatW(pathW, tmpfileW);
132
133 if (CopyFileW(source, pathW, FALSE) &&
134 MoveFileExW(file->TargetPath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT) &&
135 MoveFileExW(pathW, file->TargetPath, MOVEFILE_DELAY_UNTIL_REBOOT))
136 {
137 file->state = msifs_installed;
138 package->need_reboot = 1;
139 gle = ERROR_SUCCESS;
140 }
141 else
142 {
143 gle = GetLastError();
144 WARN("failed to schedule rename operation: %d)\n", gle);
145 }
146 msi_free(pathW);
147 }
148
149 return gle;
150 }
151
152 static UINT msi_create_directory( MSIPACKAGE *package, const WCHAR *dir )
153 {
154 MSIFOLDER *folder;
155 WCHAR *install_path;
156
157 install_path = resolve_folder( package, dir, FALSE, FALSE, TRUE, &folder );
158 if (!install_path)
159 return ERROR_FUNCTION_FAILED;
160
161 if (folder->State == 0)
162 {
163 create_full_pathW( install_path );
164 folder->State = 2;
165 }
166 msi_free( install_path );
167 return ERROR_SUCCESS;
168 }
169
170 static BOOL installfiles_cb(MSIPACKAGE *package, LPCWSTR file, DWORD action,
171 LPWSTR *path, DWORD *attrs, PVOID user)
172 {
173 static MSIFILE *f = NULL;
174 UINT_PTR disk_id = (UINT_PTR)user;
175
176 if (action == MSICABEXTRACT_BEGINEXTRACT)
177 {
178 f = get_loaded_file(package, file);
179 if (!f)
180 {
181 WARN("unknown file in cabinet (%s)\n", debugstr_w(file));
182 return FALSE;
183 }
184
185 if (f->disk_id != disk_id || (f->state != msifs_missing && f->state != msifs_overwrite))
186 return FALSE;
187
188 msi_file_update_ui(package, f, szInstallFiles);
189 msi_create_directory(package, f->Component->Directory);
190
191 *path = strdupW(f->TargetPath);
192 *attrs = f->Attributes;
193 }
194 else if (action == MSICABEXTRACT_FILEEXTRACTED)
195 {
196 f->state = msifs_installed;
197 f = NULL;
198 }
199
200 return TRUE;
201 }
202
203 /*
204 * ACTION_InstallFiles()
205 *
206 * For efficiency, this is done in two passes:
207 * 1) Correct all the TargetPaths and determine what files are to be installed.
208 * 2) Extract Cabinets and copy files.
209 */
210 UINT ACTION_InstallFiles(MSIPACKAGE *package)
211 {
212 MSIMEDIAINFO *mi;
213 UINT rc = ERROR_SUCCESS;
214 MSIFILE *file;
215
216 /* increment progress bar each time action data is sent */
217 ui_progress(package,1,1,0,0);
218
219 schedule_install_files(package);
220
221 mi = msi_alloc_zero( sizeof(MSIMEDIAINFO) );
222
223 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
224 {
225 if (file->state != msifs_missing && !mi->is_continuous && file->state != msifs_overwrite)
226 continue;
227
228 if (file->Sequence > mi->last_sequence || mi->is_continuous ||
229 (file->IsCompressed && !mi->is_extracted))
230 {
231 MSICABDATA data;
232
233 rc = ready_media(package, file, mi);
234 if (rc != ERROR_SUCCESS)
235 {
236 ERR("Failed to ready media for %s\n", debugstr_w(file->File));
237 break;
238 }
239
240 data.mi = mi;
241 data.package = package;
242 data.cb = installfiles_cb;
243 data.user = (PVOID)(UINT_PTR)mi->disk_id;
244
245 if (file->IsCompressed &&
246 !msi_cabextract(package, mi, &data))
247 {
248 ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
249 rc = ERROR_INSTALL_FAILURE;
250 break;
251 }
252 }
253
254 if (!file->IsCompressed)
255 {
256 LPWSTR source = resolve_file_source(package, file);
257
258 TRACE("file paths %s to %s\n", debugstr_w(source),
259 debugstr_w(file->TargetPath));
260
261 msi_file_update_ui(package, file, szInstallFiles);
262 msi_create_directory(package, file->Component->Directory);
263
264 rc = copy_install_file(package, file, source);
265 if (rc != ERROR_SUCCESS)
266 {
267 ERR("Failed to copy %s to %s (%d)\n", debugstr_w(source),
268 debugstr_w(file->TargetPath), rc);
269 rc = ERROR_INSTALL_FAILURE;
270 msi_free(source);
271 break;
272 }
273
274 msi_free(source);
275 }
276 else if (file->state != msifs_installed)
277 {
278 ERR("compressed file wasn't installed (%s)\n", debugstr_w(file->TargetPath));
279 rc = ERROR_INSTALL_FAILURE;
280 break;
281 }
282 }
283
284 msi_free_media_info(mi);
285 return rc;
286 }
287
288 #define is_dot_dir(x) ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
289
290 typedef struct
291 {
292 struct list entry;
293 LPWSTR sourcename;
294 LPWSTR destname;
295 LPWSTR source;
296 LPWSTR dest;
297 } FILE_LIST;
298
299 static BOOL msi_move_file(LPCWSTR source, LPCWSTR dest, int options)
300 {
301 BOOL ret;
302
303 if (GetFileAttributesW(source) == FILE_ATTRIBUTE_DIRECTORY ||
304 GetFileAttributesW(dest) == FILE_ATTRIBUTE_DIRECTORY)
305 {
306 WARN("Source or dest is directory, not moving\n");
307 return FALSE;
308 }
309
310 if (options == msidbMoveFileOptionsMove)
311 {
312 TRACE("moving %s -> %s\n", debugstr_w(source), debugstr_w(dest));
313 ret = MoveFileExW(source, dest, MOVEFILE_REPLACE_EXISTING);
314 if (!ret)
315 {
316 WARN("MoveFile failed: %d\n", GetLastError());
317 return FALSE;
318 }
319 }
320 else
321 {
322 TRACE("copying %s -> %s\n", debugstr_w(source), debugstr_w(dest));
323 ret = CopyFileW(source, dest, FALSE);
324 if (!ret)
325 {
326 WARN("CopyFile failed: %d\n", GetLastError());
327 return FALSE;
328 }
329 }
330
331 return TRUE;
332 }
333
334 static LPWSTR wildcard_to_file(LPWSTR wildcard, LPWSTR filename)
335 {
336 LPWSTR path, ptr;
337 DWORD dirlen, pathlen;
338
339 ptr = strrchrW(wildcard, '\\');
340 dirlen = ptr - wildcard + 1;
341
342 pathlen = dirlen + lstrlenW(filename) + 1;
343 path = msi_alloc(pathlen * sizeof(WCHAR));
344
345 lstrcpynW(path, wildcard, dirlen + 1);
346 lstrcatW(path, filename);
347
348 return path;
349 }
350
351 static void free_file_entry(FILE_LIST *file)
352 {
353 msi_free(file->source);
354 msi_free(file->dest);
355 msi_free(file);
356 }
357
358 static void free_list(FILE_LIST *list)
359 {
360 while (!list_empty(&list->entry))
361 {
362 FILE_LIST *file = LIST_ENTRY(list_head(&list->entry), FILE_LIST, entry);
363
364 list_remove(&file->entry);
365 free_file_entry(file);
366 }
367 }
368
369 static BOOL add_wildcard(FILE_LIST *files, LPWSTR source, LPWSTR dest)
370 {
371 FILE_LIST *new, *file;
372 LPWSTR ptr, filename;
373 DWORD size;
374
375 new = msi_alloc_zero(sizeof(FILE_LIST));
376 if (!new)
377 return FALSE;
378
379 new->source = strdupW(source);
380 ptr = strrchrW(dest, '\\') + 1;
381 filename = strrchrW(new->source, '\\') + 1;
382
383 new->sourcename = filename;
384
385 if (*ptr)
386 new->destname = ptr;
387 else
388 new->destname = new->sourcename;
389
390 size = (ptr - dest) + lstrlenW(filename) + 1;
391 new->dest = msi_alloc(size * sizeof(WCHAR));
392 if (!new->dest)
393 {
394 free_file_entry(new);
395 return FALSE;
396 }
397
398 lstrcpynW(new->dest, dest, ptr - dest + 1);
399 lstrcatW(new->dest, filename);
400
401 if (list_empty(&files->entry))
402 {
403 list_add_head(&files->entry, &new->entry);
404 return TRUE;
405 }
406
407 LIST_FOR_EACH_ENTRY(file, &files->entry, FILE_LIST, entry)
408 {
409 if (lstrcmpW(source, file->source) < 0)
410 {
411 list_add_before(&file->entry, &new->entry);
412 return TRUE;
413 }
414 }
415
416 list_add_after(&file->entry, &new->entry);
417 return TRUE;
418 }
419
420 static BOOL move_files_wildcard(LPWSTR source, LPWSTR dest, int options)
421 {
422 WIN32_FIND_DATAW wfd;
423 HANDLE hfile;
424 LPWSTR path;
425 BOOL res;
426 FILE_LIST files, *file;
427 DWORD size;
428
429 hfile = FindFirstFileW(source, &wfd);
430 if (hfile == INVALID_HANDLE_VALUE) return FALSE;
431
432 list_init(&files.entry);
433
434 for (res = TRUE; res; res = FindNextFileW(hfile, &wfd))
435 {
436 if (is_dot_dir(wfd.cFileName)) continue;
437
438 path = wildcard_to_file(source, wfd.cFileName);
439 if (!path)
440 {
441 res = FALSE;
442 goto done;
443 }
444
445 add_wildcard(&files, path, dest);
446 msi_free(path);
447 }
448
449 /* no files match the wildcard */
450 if (list_empty(&files.entry))
451 goto done;
452
453 /* only the first wildcard match gets renamed to dest */
454 file = LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
455 size = (strrchrW(file->dest, '\\') - file->dest) + lstrlenW(file->destname) + 2;
456 file->dest = msi_realloc(file->dest, size * sizeof(WCHAR));
457 if (!file->dest)
458 {
459 res = FALSE;
460 goto done;
461 }
462
463 /* file->dest may be shorter after the reallocation, so add a NULL
464 * terminator. This is needed for the call to strrchrW, as there will no
465 * longer be a NULL terminator within the bounds of the allocation in this case.
466 */
467 file->dest[size - 1] = '\0';
468 lstrcpyW(strrchrW(file->dest, '\\') + 1, file->destname);
469
470 while (!list_empty(&files.entry))
471 {
472 file = LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
473
474 msi_move_file(file->source, file->dest, options);
475
476 list_remove(&file->entry);
477 free_file_entry(file);
478 }
479
480 res = TRUE;
481
482 done:
483 free_list(&files);
484 FindClose(hfile);
485 return res;
486 }
487
488 static UINT ITERATE_MoveFiles( MSIRECORD *rec, LPVOID param )
489 {
490 MSIPACKAGE *package = param;
491 MSIRECORD *uirow;
492 MSICOMPONENT *comp;
493 LPCWSTR sourcename, component;
494 LPWSTR sourcedir, destname = NULL, destdir = NULL, source = NULL, dest = NULL;
495 int options;
496 DWORD size;
497 BOOL ret, wildcards;
498
499 component = MSI_RecordGetString(rec, 2);
500 comp = get_loaded_component(package, component);
501 if (!comp)
502 return ERROR_SUCCESS;
503
504 if (!comp->Enabled)
505 {
506 TRACE("component is disabled\n");
507 return ERROR_SUCCESS;
508 }
509
510 if (comp->ActionRequest != INSTALLSTATE_LOCAL && comp->ActionRequest != INSTALLSTATE_SOURCE)
511 {
512 TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
513 comp->Action = comp->Installed;
514 return ERROR_SUCCESS;
515 }
516 comp->Action = comp->ActionRequest;
517
518 sourcename = MSI_RecordGetString(rec, 3);
519 options = MSI_RecordGetInteger(rec, 7);
520
521 sourcedir = msi_dup_property(package->db, MSI_RecordGetString(rec, 5));
522 if (!sourcedir)
523 goto done;
524
525 destdir = msi_dup_property(package->db, MSI_RecordGetString(rec, 6));
526 if (!destdir)
527 goto done;
528
529 if (!sourcename)
530 {
531 if (GetFileAttributesW(sourcedir) == INVALID_FILE_ATTRIBUTES)
532 goto done;
533
534 source = strdupW(sourcedir);
535 if (!source)
536 goto done;
537 }
538 else
539 {
540 size = lstrlenW(sourcedir) + lstrlenW(sourcename) + 2;
541 source = msi_alloc(size * sizeof(WCHAR));
542 if (!source)
543 goto done;
544
545 lstrcpyW(source, sourcedir);
546 if (source[lstrlenW(source) - 1] != '\\')
547 lstrcatW(source, szBackSlash);
548 lstrcatW(source, sourcename);
549 }
550
551 wildcards = strchrW(source, '*') || strchrW(source, '?');
552
553 if (MSI_RecordIsNull(rec, 4))
554 {
555 if (!wildcards)
556 {
557 destname = strdupW(sourcename);
558 if (!destname)
559 goto done;
560 }
561 }
562 else
563 {
564 destname = strdupW(MSI_RecordGetString(rec, 4));
565 if (destname)
566 reduce_to_longfilename(destname);
567 }
568
569 size = 0;
570 if (destname)
571 size = lstrlenW(destname);
572
573 size += lstrlenW(destdir) + 2;
574 dest = msi_alloc(size * sizeof(WCHAR));
575 if (!dest)
576 goto done;
577
578 lstrcpyW(dest, destdir);
579 if (dest[lstrlenW(dest) - 1] != '\\')
580 lstrcatW(dest, szBackSlash);
581
582 if (destname)
583 lstrcatW(dest, destname);
584
585 if (GetFileAttributesW(destdir) == INVALID_FILE_ATTRIBUTES)
586 {
587 ret = CreateDirectoryW(destdir, NULL);
588 if (!ret)
589 {
590 WARN("CreateDirectory failed: %d\n", GetLastError());
591 goto done;
592 }
593 }
594
595 if (!wildcards)
596 msi_move_file(source, dest, options);
597 else
598 move_files_wildcard(source, dest, options);
599
600 done:
601 uirow = MSI_CreateRecord( 9 );
602 MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString(rec, 1) );
603 MSI_RecordSetInteger( uirow, 6, 1 ); /* FIXME */
604 MSI_RecordSetStringW( uirow, 9, destdir );
605 ui_actiondata( package, szMoveFiles, uirow );
606 msiobj_release( &uirow->hdr );
607
608 msi_free(sourcedir);
609 msi_free(destdir);
610 msi_free(destname);
611 msi_free(source);
612 msi_free(dest);
613
614 return ERROR_SUCCESS;
615 }
616
617 UINT ACTION_MoveFiles( MSIPACKAGE *package )
618 {
619 UINT rc;
620 MSIQUERY *view;
621
622 static const WCHAR ExecSeqQuery[] =
623 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
624 '`','M','o','v','e','F','i','l','e','`',0};
625
626 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
627 if (rc != ERROR_SUCCESS)
628 return ERROR_SUCCESS;
629
630 rc = MSI_IterateRecords(view, NULL, ITERATE_MoveFiles, package);
631 msiobj_release(&view->hdr);
632
633 return rc;
634 }
635
636 static WCHAR *get_duplicate_filename( MSIPACKAGE *package, MSIRECORD *row, const WCHAR *file_key, const WCHAR *src )
637 {
638 DWORD len;
639 WCHAR *dst_name, *dst_path, *dst;
640
641 if (MSI_RecordIsNull( row, 4 ))
642 {
643 len = strlenW( src ) + 1;
644 if (!(dst_name = msi_alloc( len * sizeof(WCHAR)))) return NULL;
645 strcpyW( dst_name, strrchrW( src, '\\' ) + 1 );
646 }
647 else
648 {
649 MSI_RecordGetStringW( row, 4, NULL, &len );
650 if (!(dst_name = msi_alloc( ++len * sizeof(WCHAR) ))) return NULL;
651 MSI_RecordGetStringW( row, 4, dst_name, &len );
652 reduce_to_longfilename( dst_name );
653 }
654
655 if (MSI_RecordIsNull( row, 5 ))
656 {
657 WCHAR *p;
658 dst_path = strdupW( src );
659 p = strrchrW( dst_path, '\\' );
660 if (p) *p = 0;
661 }
662 else
663 {
664 const WCHAR *dst_key = MSI_RecordGetString( row, 5 );
665
666 dst_path = resolve_folder( package, dst_key, FALSE, FALSE, TRUE, NULL );
667 if (!dst_path)
668 {
669 /* try a property */
670 dst_path = msi_dup_property( package->db, dst_key );
671 if (!dst_path)
672 {
673 FIXME("Unable to get destination folder, try AppSearch properties\n");
674 msi_free( dst_name );
675 return NULL;
676 }
677 }
678 }
679
680 dst = build_directory_name( 2, dst_path, dst_name );
681 create_full_pathW( dst_path );
682
683 msi_free( dst_name );
684 msi_free( dst_path );
685 return dst;
686 }
687
688 static UINT ITERATE_DuplicateFiles(MSIRECORD *row, LPVOID param)
689 {
690 MSIPACKAGE *package = param;
691 LPWSTR dest;
692 LPCWSTR file_key, component;
693 MSICOMPONENT *comp;
694 MSIRECORD *uirow;
695 MSIFILE *file;
696
697 component = MSI_RecordGetString(row,2);
698 comp = get_loaded_component(package,component);
699 if (!comp)
700 return ERROR_SUCCESS;
701
702 if (!comp->Enabled)
703 {
704 TRACE("component is disabled\n");
705 return ERROR_SUCCESS;
706 }
707
708 if (comp->ActionRequest != INSTALLSTATE_LOCAL)
709 {
710 TRACE("Component not scheduled for installation %s\n", debugstr_w(component));
711 comp->Action = comp->Installed;
712 return ERROR_SUCCESS;
713 }
714 comp->Action = INSTALLSTATE_LOCAL;
715
716 file_key = MSI_RecordGetString(row,3);
717 if (!file_key)
718 {
719 ERR("Unable to get file key\n");
720 return ERROR_FUNCTION_FAILED;
721 }
722
723 file = get_loaded_file( package, file_key );
724 if (!file)
725 {
726 ERR("Original file unknown %s\n", debugstr_w(file_key));
727 return ERROR_SUCCESS;
728 }
729
730 dest = get_duplicate_filename( package, row, file_key, file->TargetPath );
731 if (!dest)
732 {
733 WARN("Unable to get duplicate filename\n");
734 return ERROR_SUCCESS;
735 }
736
737 TRACE("Duplicating file %s to %s\n", debugstr_w(file->TargetPath), debugstr_w(dest));
738
739 if (!CopyFileW( file->TargetPath, dest, TRUE ))
740 {
741 WARN("Failed to copy file %s -> %s (%u)\n",
742 debugstr_w(file->TargetPath), debugstr_w(dest), GetLastError());
743 }
744
745 FIXME("We should track these duplicate files as well\n");
746
747 uirow = MSI_CreateRecord( 9 );
748 MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString( row, 1 ) );
749 MSI_RecordSetInteger( uirow, 6, file->FileSize );
750 MSI_RecordSetStringW( uirow, 9, MSI_RecordGetString( row, 5 ) );
751 ui_actiondata( package, szDuplicateFiles, uirow );
752 msiobj_release( &uirow->hdr );
753
754 msi_free(dest);
755 return ERROR_SUCCESS;
756 }
757
758 UINT ACTION_DuplicateFiles(MSIPACKAGE *package)
759 {
760 UINT rc;
761 MSIQUERY * view;
762 static const WCHAR ExecSeqQuery[] =
763 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
764 '`','D','u','p','l','i','c','a','t','e','F','i','l','e','`',0};
765
766 rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
767 if (rc != ERROR_SUCCESS)
768 return ERROR_SUCCESS;
769
770 rc = MSI_IterateRecords(view, NULL, ITERATE_DuplicateFiles, package);
771 msiobj_release(&view->hdr);
772
773 return rc;
774 }
775
776 static UINT ITERATE_RemoveDuplicateFiles( MSIRECORD *row, LPVOID param )
777 {
778 MSIPACKAGE *package = param;
779 LPWSTR dest;
780 LPCWSTR file_key, component;
781 MSICOMPONENT *comp;
782 MSIRECORD *uirow;
783 MSIFILE *file;
784
785 component = MSI_RecordGetString( row, 2 );
786 comp = get_loaded_component( package, component );
787 if (!comp)
788 return ERROR_SUCCESS;
789
790 if (!comp->Enabled)
791 {
792 TRACE("component is disabled\n");
793 return ERROR_SUCCESS;
794 }
795
796 if (comp->ActionRequest != INSTALLSTATE_ABSENT)
797 {
798 TRACE("Component not scheduled for removal %s\n", debugstr_w(component));
799 comp->Action = comp->Installed;
800 return ERROR_SUCCESS;
801 }
802 comp->Action = INSTALLSTATE_ABSENT;
803
804 file_key = MSI_RecordGetString( row, 3 );
805 if (!file_key)
806 {
807 ERR("Unable to get file key\n");
808 return ERROR_FUNCTION_FAILED;
809 }
810
811 file = get_loaded_file( package, file_key );
812 if (!file)
813 {
814 ERR("Original file unknown %s\n", debugstr_w(file_key));
815 return ERROR_SUCCESS;
816 }
817
818 dest = get_duplicate_filename( package, row, file_key, file->TargetPath );
819 if (!dest)
820 {
821 WARN("Unable to get duplicate filename\n");
822 return ERROR_SUCCESS;
823 }
824
825 TRACE("Removing duplicate %s of %s\n", debugstr_w(dest), debugstr_w(file->TargetPath));
826
827 if (!DeleteFileW( dest ))
828 {
829 WARN("Failed to delete duplicate file %s (%u)\n", debugstr_w(dest), GetLastError());
830 }
831
832 uirow = MSI_CreateRecord( 9 );
833 MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString( row, 1 ) );
834 MSI_RecordSetStringW( uirow, 9, MSI_RecordGetString( row, 5 ) );
835 ui_actiondata( package, szRemoveDuplicateFiles, uirow );
836 msiobj_release( &uirow->hdr );
837
838 msi_free(dest);
839 return ERROR_SUCCESS;
840 }
841
842 UINT ACTION_RemoveDuplicateFiles( MSIPACKAGE *package )
843 {
844 UINT rc;
845 MSIQUERY *view;
846 static const WCHAR query[] =
847 {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
848 '`','D','u','p','l','i','c','a','t','e','F','i','l','e','`',0};
849
850 rc = MSI_DatabaseOpenViewW( package->db, query, &view );
851 if (rc != ERROR_SUCCESS)
852 return ERROR_SUCCESS;
853
854 rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveDuplicateFiles, package );
855 msiobj_release( &view->hdr );
856
857 return rc;
858 }
859
860 static BOOL verify_comp_for_removal(MSICOMPONENT *comp, UINT install_mode)
861 {
862 INSTALLSTATE request = comp->ActionRequest;
863
864 if (request == INSTALLSTATE_UNKNOWN)
865 return FALSE;
866
867 if (install_mode == msidbRemoveFileInstallModeOnInstall &&
868 (request == INSTALLSTATE_LOCAL || request == INSTALLSTATE_SOURCE))
869 return TRUE;
870
871 if (request == INSTALLSTATE_ABSENT)
872 {
873 if (!comp->ComponentId)
874 return FALSE;
875
876 if (install_mode == msidbRemoveFileInstallModeOnRemove)
877 return TRUE;
878 }
879
880 if (install_mode == msidbRemoveFileInstallModeOnBoth)
881 return TRUE;
882
883 return FALSE;
884 }
885
886 static UINT ITERATE_RemoveFiles(MSIRECORD *row, LPVOID param)
887 {
888 MSIPACKAGE *package = param;
889 MSICOMPONENT *comp;
890 MSIRECORD *uirow;
891 LPCWSTR component, filename, dirprop;
892 UINT install_mode;
893 LPWSTR dir = NULL, path = NULL;
894 DWORD size;
895 UINT ret = ERROR_SUCCESS;
896
897 component = MSI_RecordGetString(row, 2);
898 filename = MSI_RecordGetString(row, 3);
899 dirprop = MSI_RecordGetString(row, 4);
900 install_mode = MSI_RecordGetInteger(row, 5);
901
902 comp = get_loaded_component(package, component);
903 if (!comp)
904 {
905 ERR("Invalid component: %s\n", debugstr_w(component));
906 return ERROR_FUNCTION_FAILED;
907 }
908
909 if (!comp->Enabled)
910 {
911 TRACE("component is disabled\n");
912 return ERROR_SUCCESS;
913 }
914
915 if (!verify_comp_for_removal(comp, install_mode))
916 {
917 TRACE("Skipping removal due to missing conditions\n");
918 comp->Action = comp->Installed;
919 return ERROR_SUCCESS;
920 }
921
922 dir = msi_dup_property(package->db, dirprop);
923 if (!dir)
924 return ERROR_OUTOFMEMORY;
925
926 size = (filename != NULL) ? lstrlenW(filename) : 0;
927 size += lstrlenW(dir) + 2;
928 path = msi_alloc(size * sizeof(WCHAR));
929 if (!path)
930 {
931 ret = ERROR_OUTOFMEMORY;
932 goto done;
933 }
934
935 if (filename)
936 {
937 lstrcpyW(path, dir);
938 PathAddBackslashW(path);
939 lstrcatW(path, filename);
940
941 TRACE("Deleting misc file: %s\n", debugstr_w(path));
942 DeleteFileW(path);
943 }
944 else
945 {
946 TRACE("Removing misc directory: %s\n", debugstr_w(dir));
947 RemoveDirectoryW(dir);
948 }
949
950 done:
951 uirow = MSI_CreateRecord( 9 );
952 MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString(row, 1) );
953 MSI_RecordSetStringW( uirow, 9, dir );
954 ui_actiondata( package, szRemoveFiles, uirow );
955 msiobj_release( &uirow->hdr );
956
957 msi_free(path);
958 msi_free(dir);
959 return ret;
960 }
961
962 UINT ACTION_RemoveFiles( MSIPACKAGE *package )
963 {
964 MSIQUERY *view;
965 MSIFILE *file;
966 UINT r;
967
968 static const WCHAR query[] = {
969 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
970 '`','R','e','m','o','v','e','F','i','l','e','`',0};
971 static const WCHAR folder_query[] = {
972 'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
973 '`','C','r','e','a','t','e','F','o','l','d','e','r','`',0};
974
975 r = MSI_DatabaseOpenViewW(package->db, query, &view);
976 if (r == ERROR_SUCCESS)
977 {
978 MSI_IterateRecords(view, NULL, ITERATE_RemoveFiles, package);
979 msiobj_release(&view->hdr);
980 }
981
982 r = MSI_DatabaseOpenViewW(package->db, folder_query, &view);
983 if (r == ERROR_SUCCESS)
984 msiobj_release(&view->hdr);
985
986 LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
987 {
988 MSIRECORD *uirow;
989 LPWSTR dir, p;
990 VS_FIXEDFILEINFO *ver;
991
992 if ( file->state == msifs_installed )
993 ERR("removing installed file %s\n", debugstr_w(file->TargetPath));
994
995 if ( file->Component->ActionRequest != INSTALLSTATE_ABSENT ||
996 file->Component->Installed == INSTALLSTATE_SOURCE )
997 continue;
998
999 if (!file->Component->Enabled)
1000 {
1001 TRACE("component is disabled\n");
1002 continue;
1003 }
1004
1005 if (file->Version)
1006 {
1007 ver = msi_get_disk_file_version( file->TargetPath );
1008 if (ver && msi_compare_file_versions( ver, file->Version ) > 0)
1009 {
1010 TRACE("newer version detected, not removing file\n");
1011 msi_free( ver );
1012 continue;
1013 }
1014 msi_free( ver );
1015 }
1016
1017 TRACE("removing %s\n", debugstr_w(file->File) );
1018 if (!DeleteFileW( file->TargetPath ))
1019 {
1020 WARN("failed to delete %s\n", debugstr_w(file->TargetPath));
1021 }
1022 /* FIXME: check persistence for each directory */
1023 else if (r && (dir = strdupW( file->TargetPath )))
1024 {
1025 if ((p = strrchrW( dir, '\\' ))) *p = 0;
1026 RemoveDirectoryW( dir );
1027 msi_free( dir );
1028 }
1029 file->state = msifs_missing;
1030
1031 uirow = MSI_CreateRecord( 9 );
1032 MSI_RecordSetStringW( uirow, 1, file->FileName );
1033 MSI_RecordSetStringW( uirow, 9, file->Component->Directory );
1034 ui_actiondata( package, szRemoveFiles, uirow );
1035 msiobj_release( &uirow->hdr );
1036 /* FIXME: call ui_progress here? */
1037 }
1038
1039 return ERROR_SUCCESS;
1040 }