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