git.oblomov.eu Git - wine/blob - dlls/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
  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 HMODULE hmspatcha;
  51 static BOOL (WINAPI *ApplyPatchToFileW)(LPCWSTR, LPCWSTR, LPCWSTR, ULONG);
  52
  53 static void msi_file_update_ui( MSIPACKAGE *package, MSIFILE *f, const WCHAR *action )
  54 {
  55     MSIRECORD *uirow;
  56
  57     uirow = MSI_CreateRecord( 9 );
  58     MSI_RecordSetStringW( uirow, 1, f->FileName );
  59     MSI_RecordSetStringW( uirow, 9, f->Component->Directory );
  60     MSI_RecordSetInteger( uirow, 6, f->FileSize );
  61     ui_actiondata( package, action, uirow );
  62     msiobj_release( &uirow->hdr );
  63     ui_progress( package, 2, f->FileSize, 0, 0 );
  64 }
  65
  66 static msi_file_state calculate_install_state( MSIFILE *file )
  67 {
  68     MSICOMPONENT *comp = file->Component;
  69     VS_FIXEDFILEINFO *file_version;
  70     WCHAR *font_version;
  71     msi_file_state state;
  72     DWORD file_size;
  73
  74     if (comp->ActionRequest != INSTALLSTATE_LOCAL || !comp->Enabled ||
  75         (comp->assembly && comp->assembly->installed))
  76     {
  77         TRACE("file %s is not scheduled for install\n", debugstr_w(file->File));
  78         return msifs_skipped;
  79     }
  80     if ((comp->assembly && !comp->assembly->application && !comp->assembly->installed) ||
  81         GetFileAttributesW( file->TargetPath ) == INVALID_FILE_ATTRIBUTES)
  82     {
  83         TRACE("file %s is missing\n", debugstr_w(file->File));
  84         return msifs_missing;
  85     }
  86     if (file->Version)
  87     {
  88         if ((file_version = msi_get_disk_file_version( file->TargetPath )))
  89         {
  90             TRACE("new %s old %u.%u.%u.%u\n", debugstr_w(file->Version),
  91                   HIWORD(file_version->dwFileVersionMS),
  92                   LOWORD(file_version->dwFileVersionMS),
  93                   HIWORD(file_version->dwFileVersionLS),
  94                   LOWORD(file_version->dwFileVersionLS));
  95
  96             if (msi_compare_file_versions( file_version, file->Version ) < 0)
  97                 state = msifs_overwrite;
  98             else
  99             {
 100                 TRACE("destination file version equal or greater, not overwriting\n");
 101                 state = msifs_present;
 102             }
 103             msi_free( file_version );
 104             return state;
 105         }
 106         else if ((font_version = font_version_from_file( file->TargetPath )))
 107         {
 108             TRACE("new %s old %s\n", debugstr_w(file->Version), debugstr_w(font_version));
 109
 110             if (msi_compare_font_versions( font_version, file->Version ) < 0)
 111                 state = msifs_overwrite;
 112             else
 113             {
 114                 TRACE("destination file version equal or greater, not overwriting\n");
 115                 state = msifs_present;
 116             }
 117             msi_free( font_version );
 118             return state;
 119         }
 120     }
 121     if ((file_size = msi_get_disk_file_size( file->TargetPath )) != file->FileSize)
 122     {
 123         return msifs_overwrite;
 124     }
 125     if (file->hash.dwFileHashInfoSize)
 126     {
 127         if (msi_file_hash_matches( file ))
 128         {
 129             TRACE("file hashes match, not overwriting\n");
 130             return msifs_hashmatch;
 131         }
 132         else
 133         {
 134             TRACE("file hashes do not match, overwriting\n");
 135             return msifs_overwrite;
 136         }
 137     }
 138     /* assume present */
 139     return msifs_present;
 140 }
 141
 142 static void schedule_install_files(MSIPACKAGE *package)
 143 {
 144     MSIFILE *file;
 145
 146     LIST_FOR_EACH_ENTRY(file, &package->files, MSIFILE, entry)
 147     {
 148         MSICOMPONENT *comp = file->Component;
 149
 150         file->state = calculate_install_state( file );
 151         if (file->state == msifs_overwrite && (comp->Attributes & msidbComponentAttributesNeverOverwrite))
 152         {
 153             TRACE("not overwriting %s\n", debugstr_w(file->TargetPath));
 154             file->state = msifs_skipped;
 155         }
 156         comp->Action = INSTALLSTATE_LOCAL;
 157         ui_progress( package, 2, file->FileSize, 0, 0 );
 158     }
 159 }
 160
 161 static UINT copy_file(MSIFILE *file, LPWSTR source)
 162 {
 163     BOOL ret;
 164
 165     ret = CopyFileW(source, file->TargetPath, FALSE);
 166     if (!ret)
 167         return GetLastError();
 168
 169     SetFileAttributesW(file->TargetPath, FILE_ATTRIBUTE_NORMAL);
 170
 171     file->state = msifs_installed;
 172     return ERROR_SUCCESS;
 173 }
 174
 175 static UINT copy_install_file(MSIPACKAGE *package, MSIFILE *file, LPWSTR source)
 176 {
 177     UINT gle;
 178
 179     TRACE("Copying %s to %s\n", debugstr_w(source), debugstr_w(file->TargetPath));
 180
 181     gle = copy_file(file, source);
 182     if (gle == ERROR_SUCCESS)
 183         return gle;
 184
 185     if (gle == ERROR_ALREADY_EXISTS && file->state == msifs_overwrite)
 186     {
 187         TRACE("overwriting existing file\n");
 188         return ERROR_SUCCESS;
 189     }
 190     else if (gle == ERROR_ACCESS_DENIED)
 191     {
 192         SetFileAttributesW(file->TargetPath, FILE_ATTRIBUTE_NORMAL);
 193
 194         gle = copy_file(file, source);
 195         TRACE("Overwriting existing file: %d\n", gle);
 196     }
 197     if (gle == ERROR_SHARING_VIOLATION || gle == ERROR_USER_MAPPED_FILE)
 198     {
 199         WCHAR tmpfileW[MAX_PATH], *pathW, *p;
 200         DWORD len;
 201
 202         TRACE("file in use, scheduling rename operation\n");
 203
 204         GetTempFileNameW(szBackSlash, szMsi, 0, tmpfileW);
 205         len = strlenW(file->TargetPath) + strlenW(tmpfileW) + 1;
 206         if (!(pathW = msi_alloc(len * sizeof(WCHAR))))
 207             return ERROR_OUTOFMEMORY;
 208
 209         strcpyW(pathW, file->TargetPath);
 210         if ((p = strrchrW(pathW, '\\'))) *p = 0;
 211         strcatW(pathW, tmpfileW);
 212
 213         if (CopyFileW(source, pathW, FALSE) &&
 214             MoveFileExW(file->TargetPath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT) &&
 215             MoveFileExW(pathW, file->TargetPath, MOVEFILE_DELAY_UNTIL_REBOOT))
 216         {
 217             file->state = msifs_installed;
 218             package->need_reboot = 1;
 219             gle = ERROR_SUCCESS;
 220         }
 221         else
 222         {
 223             gle = GetLastError();
 224             WARN("failed to schedule rename operation: %d)\n", gle);
 225         }
 226         msi_free(pathW);
 227     }
 228
 229     return gle;
 230 }
 231
 232 static UINT msi_create_directory( MSIPACKAGE *package, const WCHAR *dir )
 233 {
 234     MSIFOLDER *folder;
 235     const WCHAR *install_path;
 236
 237     install_path = msi_get_target_folder( package, dir );
 238     if (!install_path) return ERROR_FUNCTION_FAILED;
 239
 240     folder = get_loaded_folder( package, dir );
 241     if (folder->State == 0)
 242     {
 243         create_full_pathW( install_path );
 244         folder->State = 2;
 245     }
 246     return ERROR_SUCCESS;
 247 }
 248
 249 static BOOL installfiles_cb(MSIPACKAGE *package, LPCWSTR file, DWORD action,
 250                             LPWSTR *path, DWORD *attrs, PVOID user)
 251 {
 252     static MSIFILE *f = NULL;
 253     UINT_PTR disk_id = (UINT_PTR)user;
 254
 255     if (action == MSICABEXTRACT_BEGINEXTRACT)
 256     {
 257         f = get_loaded_file(package, file);
 258         if (!f)
 259         {
 260             TRACE("unknown file in cabinet (%s)\n", debugstr_w(file));
 261             return FALSE;
 262         }
 263
 264         if (f->disk_id != disk_id || (f->state != msifs_missing && f->state != msifs_overwrite))
 265             return FALSE;
 266
 267         msi_file_update_ui(package, f, szInstallFiles);
 268         if (!f->Component->assembly || f->Component->assembly->application)
 269         {
 270             msi_create_directory(package, f->Component->Directory);
 271         }
 272         *path = strdupW(f->TargetPath);
 273         *attrs = f->Attributes;
 274     }
 275     else if (action == MSICABEXTRACT_FILEEXTRACTED)
 276     {
 277         f->state = msifs_installed;
 278         f = NULL;
 279     }
 280
 281     return TRUE;
 282 }
 283
 284 /*
 285  * ACTION_InstallFiles()
 286  *
 287  * For efficiency, this is done in two passes:
 288  * 1) Correct all the TargetPaths and determine what files are to be installed.
 289  * 2) Extract Cabinets and copy files.
 290  */
 291 UINT ACTION_InstallFiles(MSIPACKAGE *package)
 292 {
 293     MSIMEDIAINFO *mi;
 294     MSICOMPONENT *comp;
 295     UINT rc = ERROR_SUCCESS;
 296     MSIFILE *file;
 297
 298     /* increment progress bar each time action data is sent */
 299     ui_progress(package,1,1,0,0);
 300
 301     schedule_install_files(package);
 302
 303     mi = msi_alloc_zero( sizeof(MSIMEDIAINFO) );
 304
 305     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
 306     {
 307         rc = msi_load_media_info( package, file->Sequence, mi );
 308         if (rc != ERROR_SUCCESS)
 309         {
 310             ERR("Unable to load media info for %s (%u)\n", debugstr_w(file->File), rc);
 311             return ERROR_FUNCTION_FAILED;
 312         }
 313         if (!file->Component->Enabled) continue;
 314
 315         if (file->state != msifs_hashmatch &&
 316             (rc = ready_media( package, file->Sequence, file->IsCompressed, mi )))
 317         {
 318             ERR("Failed to ready media for %s\n", debugstr_w(file->File));
 319             goto done;
 320         }
 321
 322         if (file->state != msifs_missing && !mi->is_continuous && file->state != msifs_overwrite)
 323             continue;
 324
 325         if (file->Sequence > mi->last_sequence || mi->is_continuous ||
 326             (file->IsCompressed && !mi->is_extracted))
 327         {
 328             MSICABDATA data;
 329
 330             data.mi = mi;
 331             data.package = package;
 332             data.cb = installfiles_cb;
 333             data.user = (PVOID)(UINT_PTR)mi->disk_id;
 334
 335             if (file->IsCompressed &&
 336                 !msi_cabextract(package, mi, &data))
 337             {
 338                 ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
 339                 rc = ERROR_INSTALL_FAILURE;
 340                 goto done;
 341             }
 342         }
 343
 344         if (!file->IsCompressed)
 345         {
 346             LPWSTR source = resolve_file_source(package, file);
 347
 348             TRACE("copying %s to %s\n", debugstr_w(source), debugstr_w(file->TargetPath));
 349
 350             msi_file_update_ui(package, file, szInstallFiles);
 351             if (!file->Component->assembly || file->Component->assembly->application)
 352             {
 353                 msi_create_directory(package, file->Component->Directory);
 354             }
 355             rc = copy_install_file(package, file, source);
 356             if (rc != ERROR_SUCCESS)
 357             {
 358                 ERR("Failed to copy %s to %s (%d)\n", debugstr_w(source),
 359                     debugstr_w(file->TargetPath), rc);
 360                 rc = ERROR_INSTALL_FAILURE;
 361                 msi_free(source);
 362                 goto done;
 363             }
 364             msi_free(source);
 365         }
 366         else if (file->state != msifs_installed && !(file->Attributes & msidbFileAttributesPatchAdded))
 367         {
 368             ERR("compressed file wasn't installed (%s)\n", debugstr_w(file->TargetPath));
 369             rc = ERROR_INSTALL_FAILURE;
 370             goto done;
 371         }
 372     }
 373     LIST_FOR_EACH_ENTRY( comp, &package->components, MSICOMPONENT, entry )
 374     {
 375         if (comp->ActionRequest == INSTALLSTATE_LOCAL && comp->Enabled &&
 376             comp->assembly && !comp->assembly->installed)
 377         {
 378             rc = install_assembly( package, comp );
 379             if (rc != ERROR_SUCCESS)
 380             {
 381                 ERR("Failed to install assembly\n");
 382                 rc = ERROR_INSTALL_FAILURE;
 383                 break;
 384             }
 385         }
 386     }
 387
 388 done:
 389     msi_free_media_info(mi);
 390     return rc;
 391 }
 392
 393 static BOOL load_mspatcha(void)
 394 {
 395     hmspatcha = LoadLibraryA("mspatcha.dll");
 396     if (!hmspatcha)
 397     {
 398         ERR("Failed to load mspatcha.dll: %d\n", GetLastError());
 399         return FALSE;
 400     }
 401
 402     ApplyPatchToFileW = (void*)GetProcAddress(hmspatcha, "ApplyPatchToFileW");
 403     if(!ApplyPatchToFileW)
 404     {
 405         ERR("GetProcAddress(ApplyPatchToFileW) failed: %d.\n", GetLastError());
 406         return FALSE;
 407     }
 408
 409     return TRUE;
 410 }
 411
 412 static void unload_mspatch(void)
 413 {
 414     FreeLibrary(hmspatcha);
 415 }
 416
 417 static BOOL patchfiles_cb(MSIPACKAGE *package, LPCWSTR file, DWORD action,
 418                           LPWSTR *path, DWORD *attrs, PVOID user)
 419 {
 420     static MSIFILEPATCH *p = NULL;
 421     static WCHAR patch_path[MAX_PATH] = {0};
 422     static WCHAR temp_folder[MAX_PATH] = {0};
 423
 424     if (action == MSICABEXTRACT_BEGINEXTRACT)
 425     {
 426         if (temp_folder[0] == '\0')
 427             GetTempPathW(MAX_PATH, temp_folder);
 428
 429         p = get_loaded_filepatch(package, file);
 430         if (!p)
 431         {
 432             TRACE("unknown file in cabinet (%s)\n", debugstr_w(file));
 433             return FALSE;
 434         }
 435
 436         msi_file_update_ui(package, p->File, szPatchFiles);
 437
 438         GetTempFileNameW(temp_folder, NULL, 0, patch_path);
 439
 440         *path = strdupW(patch_path);
 441         *attrs = p->File->Attributes;
 442     }
 443     else if (action == MSICABEXTRACT_FILEEXTRACTED)
 444     {
 445         WCHAR patched_file[MAX_PATH];
 446         BOOL br;
 447
 448         GetTempFileNameW(temp_folder, NULL, 0, patched_file);
 449
 450         br = ApplyPatchToFileW(patch_path, p->File->TargetPath, patched_file, 0);
 451         if (br)
 452         {
 453             /* FIXME: baseline cache */
 454
 455             DeleteFileW( p->File->TargetPath );
 456             MoveFileW( patched_file, p->File->TargetPath );
 457
 458             p->IsApplied = TRUE;
 459         }
 460         else
 461             ERR("Failed patch %s: %d.\n", debugstr_w(p->File->TargetPath), GetLastError());
 462
 463         DeleteFileW(patch_path);
 464         p = NULL;
 465     }
 466
 467     return TRUE;
 468 }
 469
 470 UINT ACTION_PatchFiles( MSIPACKAGE *package )
 471 {
 472     MSIFILEPATCH *patch;
 473     MSIMEDIAINFO *mi;
 474     UINT rc = ERROR_SUCCESS;
 475     BOOL mspatcha_loaded = FALSE;
 476
 477     TRACE("%p\n", package);
 478
 479     /* increment progress bar each time action data is sent */
 480     ui_progress(package,1,1,0,0);
 481
 482     mi = msi_alloc_zero( sizeof(MSIMEDIAINFO) );
 483
 484     LIST_FOR_EACH_ENTRY( patch, &package->filepatches, MSIFILEPATCH, entry )
 485     {
 486         MSIFILE *file = patch->File;
 487
 488         rc = msi_load_media_info( package, patch->Sequence, mi );
 489         if (rc != ERROR_SUCCESS)
 490         {
 491             ERR("Unable to load media info for %s (%u)\n", debugstr_w(file->File), rc);
 492             return ERROR_FUNCTION_FAILED;
 493         }
 494         if (!file->Component->Enabled) continue;
 495
 496         if (!patch->IsApplied)
 497         {
 498             MSICABDATA data;
 499
 500             rc = ready_media( package, patch->Sequence, TRUE, mi );
 501             if (rc != ERROR_SUCCESS)
 502             {
 503                 ERR("Failed to ready media for %s\n", debugstr_w(file->File));
 504                 goto done;
 505             }
 506
 507             if (!mspatcha_loaded && !load_mspatcha())
 508             {
 509                 rc = ERROR_FUNCTION_FAILED;
 510                 goto done;
 511             }
 512             mspatcha_loaded = TRUE;
 513
 514             data.mi = mi;
 515             data.package = package;
 516             data.cb = patchfiles_cb;
 517             data.user = (PVOID)(UINT_PTR)mi->disk_id;
 518
 519             if (!msi_cabextract(package, mi, &data))
 520             {
 521                 ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
 522                 rc = ERROR_INSTALL_FAILURE;
 523                 goto done;
 524             }
 525         }
 526
 527         if (!patch->IsApplied && !(patch->Attributes & msidbPatchAttributesNonVital))
 528         {
 529             ERR("Failed to apply patch to file: %s\n", debugstr_w(file->File));
 530             rc = ERROR_INSTALL_FAILURE;
 531             goto done;
 532         }
 533     }
 534
 535 done:
 536     msi_free_media_info(mi);
 537     if (mspatcha_loaded)
 538         unload_mspatch();
 539     return rc;
 540 }
 541
 542 #define is_dot_dir(x) ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
 543
 544 typedef struct
 545 {
 546     struct list entry;
 547     LPWSTR sourcename;
 548     LPWSTR destname;
 549     LPWSTR source;
 550     LPWSTR dest;
 551 } FILE_LIST;
 552
 553 static BOOL msi_move_file(LPCWSTR source, LPCWSTR dest, int options)
 554 {
 555     BOOL ret;
 556
 557     if (GetFileAttributesW(source) == FILE_ATTRIBUTE_DIRECTORY ||
 558         GetFileAttributesW(dest) == FILE_ATTRIBUTE_DIRECTORY)
 559     {
 560         WARN("Source or dest is directory, not moving\n");
 561         return FALSE;
 562     }
 563
 564     if (options == msidbMoveFileOptionsMove)
 565     {
 566         TRACE("moving %s -> %s\n", debugstr_w(source), debugstr_w(dest));
 567         ret = MoveFileExW(source, dest, MOVEFILE_REPLACE_EXISTING);
 568         if (!ret)
 569         {
 570             WARN("MoveFile failed: %d\n", GetLastError());
 571             return FALSE;
 572         }
 573     }
 574     else
 575     {
 576         TRACE("copying %s -> %s\n", debugstr_w(source), debugstr_w(dest));
 577         ret = CopyFileW(source, dest, FALSE);
 578         if (!ret)
 579         {
 580             WARN("CopyFile failed: %d\n", GetLastError());
 581             return FALSE;
 582         }
 583     }
 584
 585     return TRUE;
 586 }
 587
 588 static LPWSTR wildcard_to_file(LPWSTR wildcard, LPWSTR filename)
 589 {
 590     LPWSTR path, ptr;
 591     DWORD dirlen, pathlen;
 592
 593     ptr = strrchrW(wildcard, '\\');
 594     dirlen = ptr - wildcard + 1;
 595
 596     pathlen = dirlen + lstrlenW(filename) + 1;
 597     path = msi_alloc(pathlen * sizeof(WCHAR));
 598
 599     lstrcpynW(path, wildcard, dirlen + 1);
 600     lstrcatW(path, filename);
 601
 602     return path;
 603 }
 604
 605 static void free_file_entry(FILE_LIST *file)
 606 {
 607     msi_free(file->source);
 608     msi_free(file->dest);
 609     msi_free(file);
 610 }
 611
 612 static void free_list(FILE_LIST *list)
 613 {
 614     while (!list_empty(&list->entry))
 615     {
 616         FILE_LIST *file = LIST_ENTRY(list_head(&list->entry), FILE_LIST, entry);
 617
 618         list_remove(&file->entry);
 619         free_file_entry(file);
 620     }
 621 }
 622
 623 static BOOL add_wildcard(FILE_LIST *files, LPWSTR source, LPWSTR dest)
 624 {
 625     FILE_LIST *new, *file;
 626     LPWSTR ptr, filename;
 627     DWORD size;
 628
 629     new = msi_alloc_zero(sizeof(FILE_LIST));
 630     if (!new)
 631         return FALSE;
 632
 633     new->source = strdupW(source);
 634     ptr = strrchrW(dest, '\\') + 1;
 635     filename = strrchrW(new->source, '\\') + 1;
 636
 637     new->sourcename = filename;
 638
 639     if (*ptr)
 640         new->destname = ptr;
 641     else
 642         new->destname = new->sourcename;
 643
 644     size = (ptr - dest) + lstrlenW(filename) + 1;
 645     new->dest = msi_alloc(size * sizeof(WCHAR));
 646     if (!new->dest)
 647     {
 648         free_file_entry(new);
 649         return FALSE;
 650     }
 651
 652     lstrcpynW(new->dest, dest, ptr - dest + 1);
 653     lstrcatW(new->dest, filename);
 654
 655     if (list_empty(&files->entry))
 656     {
 657         list_add_head(&files->entry, &new->entry);
 658         return TRUE;
 659     }
 660
 661     LIST_FOR_EACH_ENTRY(file, &files->entry, FILE_LIST, entry)
 662     {
 663         if (strcmpW( source, file->source ) < 0)
 664         {
 665             list_add_before(&file->entry, &new->entry);
 666             return TRUE;
 667         }
 668     }
 669
 670     list_add_after(&file->entry, &new->entry);
 671     return TRUE;
 672 }
 673
 674 static BOOL move_files_wildcard(LPWSTR source, LPWSTR dest, int options)
 675 {
 676     WIN32_FIND_DATAW wfd;
 677     HANDLE hfile;
 678     LPWSTR path;
 679     BOOL res;
 680     FILE_LIST files, *file;
 681     DWORD size;
 682
 683     hfile = FindFirstFileW(source, &wfd);
 684     if (hfile == INVALID_HANDLE_VALUE) return FALSE;
 685
 686     list_init(&files.entry);
 687
 688     for (res = TRUE; res; res = FindNextFileW(hfile, &wfd))
 689     {
 690         if (is_dot_dir(wfd.cFileName)) continue;
 691
 692         path = wildcard_to_file(source, wfd.cFileName);
 693         if (!path)
 694         {
 695             res = FALSE;
 696             goto done;
 697         }
 698
 699         add_wildcard(&files, path, dest);
 700         msi_free(path);
 701     }
 702
 703     /* no files match the wildcard */
 704     if (list_empty(&files.entry))
 705         goto done;
 706
 707     /* only the first wildcard match gets renamed to dest */
 708     file = LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
 709     size = (strrchrW(file->dest, '\\') - file->dest) + lstrlenW(file->destname) + 2;
 710     file->dest = msi_realloc(file->dest, size * sizeof(WCHAR));
 711     if (!file->dest)
 712     {
 713         res = FALSE;
 714         goto done;
 715     }
 716
 717     /* file->dest may be shorter after the reallocation, so add a NULL
 718      * terminator.  This is needed for the call to strrchrW, as there will no
 719      * longer be a NULL terminator within the bounds of the allocation in this case.
 720      */
 721     file->dest[size - 1] = '\0';
 722     lstrcpyW(strrchrW(file->dest, '\\') + 1, file->destname);
 723
 724     while (!list_empty(&files.entry))
 725     {
 726         file = LIST_ENTRY(list_head(&files.entry), FILE_LIST, entry);
 727
 728         msi_move_file(file->source, file->dest, options);
 729
 730         list_remove(&file->entry);
 731         free_file_entry(file);
 732     }
 733
 734     res = TRUE;
 735
 736 done:
 737     free_list(&files);
 738     FindClose(hfile);
 739     return res;
 740 }
 741
 742 static UINT ITERATE_MoveFiles( MSIRECORD *rec, LPVOID param )
 743 {
 744     MSIPACKAGE *package = param;
 745     MSIRECORD *uirow;
 746     MSICOMPONENT *comp;
 747     LPCWSTR sourcename, component;
 748     LPWSTR sourcedir, destname = NULL, destdir = NULL, source = NULL, dest = NULL;
 749     int options;
 750     DWORD size;
 751     BOOL ret, wildcards;
 752
 753     component = MSI_RecordGetString(rec, 2);
 754     comp = get_loaded_component(package, component);
 755     if (!comp)
 756         return ERROR_SUCCESS;
 757
 758     if (!comp->Enabled)
 759     {
 760         TRACE("component is disabled\n");
 761         return ERROR_SUCCESS;
 762     }
 763
 764     if (comp->ActionRequest != INSTALLSTATE_LOCAL && comp->ActionRequest != INSTALLSTATE_SOURCE)
 765     {
 766         TRACE("Component not scheduled for installation: %s\n", debugstr_w(component));
 767         comp->Action = comp->Installed;
 768         return ERROR_SUCCESS;
 769     }
 770     comp->Action = comp->ActionRequest;
 771
 772     sourcename = MSI_RecordGetString(rec, 3);
 773     options = MSI_RecordGetInteger(rec, 7);
 774
 775     sourcedir = msi_dup_property(package->db, MSI_RecordGetString(rec, 5));
 776     if (!sourcedir)
 777         goto done;
 778
 779     destdir = msi_dup_property(package->db, MSI_RecordGetString(rec, 6));
 780     if (!destdir)
 781         goto done;
 782
 783     if (!sourcename)
 784     {
 785         if (GetFileAttributesW(sourcedir) == INVALID_FILE_ATTRIBUTES)
 786             goto done;
 787
 788         source = strdupW(sourcedir);
 789         if (!source)
 790             goto done;
 791     }
 792     else
 793     {
 794         size = lstrlenW(sourcedir) + lstrlenW(sourcename) + 2;
 795         source = msi_alloc(size * sizeof(WCHAR));
 796         if (!source)
 797             goto done;
 798
 799         lstrcpyW(source, sourcedir);
 800         if (source[lstrlenW(source) - 1] != '\\')
 801             lstrcatW(source, szBackSlash);
 802         lstrcatW(source, sourcename);
 803     }
 804
 805     wildcards = strchrW(source, '*') || strchrW(source, '?');
 806
 807     if (MSI_RecordIsNull(rec, 4))
 808     {
 809         if (!wildcards)
 810         {
 811             destname = strdupW(sourcename);
 812             if (!destname)
 813                 goto done;
 814         }
 815     }
 816     else
 817     {
 818         destname = strdupW(MSI_RecordGetString(rec, 4));
 819         if (destname)
 820             reduce_to_longfilename(destname);
 821     }
 822
 823     size = 0;
 824     if (destname)
 825         size = lstrlenW(destname);
 826
 827     size += lstrlenW(destdir) + 2;
 828     dest = msi_alloc(size * sizeof(WCHAR));
 829     if (!dest)
 830         goto done;
 831
 832     lstrcpyW(dest, destdir);
 833     if (dest[lstrlenW(dest) - 1] != '\\')
 834         lstrcatW(dest, szBackSlash);
 835
 836     if (destname)
 837         lstrcatW(dest, destname);
 838
 839     if (GetFileAttributesW(destdir) == INVALID_FILE_ATTRIBUTES)
 840     {
 841         ret = CreateDirectoryW(destdir, NULL);
 842         if (!ret)
 843         {
 844             WARN("CreateDirectory failed: %d\n", GetLastError());
 845             goto done;
 846         }
 847     }
 848
 849     if (!wildcards)
 850         msi_move_file(source, dest, options);
 851     else
 852         move_files_wildcard(source, dest, options);
 853
 854 done:
 855     uirow = MSI_CreateRecord( 9 );
 856     MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString(rec, 1) );
 857     MSI_RecordSetInteger( uirow, 6, 1 ); /* FIXME */
 858     MSI_RecordSetStringW( uirow, 9, destdir );
 859     ui_actiondata( package, szMoveFiles, uirow );
 860     msiobj_release( &uirow->hdr );
 861
 862     msi_free(sourcedir);
 863     msi_free(destdir);
 864     msi_free(destname);
 865     msi_free(source);
 866     msi_free(dest);
 867
 868     return ERROR_SUCCESS;
 869 }
 870
 871 UINT ACTION_MoveFiles( MSIPACKAGE *package )
 872 {
 873     UINT rc;
 874     MSIQUERY *view;
 875
 876     static const WCHAR ExecSeqQuery[] =
 877         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 878          '`','M','o','v','e','F','i','l','e','`',0};
 879
 880     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 881     if (rc != ERROR_SUCCESS)
 882         return ERROR_SUCCESS;
 883
 884     rc = MSI_IterateRecords(view, NULL, ITERATE_MoveFiles, package);
 885     msiobj_release(&view->hdr);
 886
 887     return rc;
 888 }
 889
 890 static WCHAR *get_duplicate_filename( MSIPACKAGE *package, MSIRECORD *row, const WCHAR *file_key, const WCHAR *src )
 891 {
 892     DWORD len;
 893     WCHAR *dst_name, *dst_path, *dst;
 894
 895     if (MSI_RecordIsNull( row, 4 ))
 896     {
 897         len = strlenW( src ) + 1;
 898         if (!(dst_name = msi_alloc( len * sizeof(WCHAR)))) return NULL;
 899         strcpyW( dst_name, strrchrW( src, '\\' ) + 1 );
 900     }
 901     else
 902     {
 903         MSI_RecordGetStringW( row, 4, NULL, &len );
 904         if (!(dst_name = msi_alloc( ++len * sizeof(WCHAR) ))) return NULL;
 905         MSI_RecordGetStringW( row, 4, dst_name, &len );
 906         reduce_to_longfilename( dst_name );
 907     }
 908
 909     if (MSI_RecordIsNull( row, 5 ))
 910     {
 911         WCHAR *p;
 912         dst_path = strdupW( src );
 913         p = strrchrW( dst_path, '\\' );
 914         if (p) *p = 0;
 915     }
 916     else
 917     {
 918         const WCHAR *dst_key = MSI_RecordGetString( row, 5 );
 919
 920         dst_path = strdupW( msi_get_target_folder( package, dst_key ) );
 921         if (!dst_path)
 922         {
 923             /* try a property */
 924             dst_path = msi_dup_property( package->db, dst_key );
 925             if (!dst_path)
 926             {
 927                 FIXME("Unable to get destination folder, try AppSearch properties\n");
 928                 msi_free( dst_name );
 929                 return NULL;
 930             }
 931         }
 932     }
 933
 934     dst = build_directory_name( 2, dst_path, dst_name );
 935     create_full_pathW( dst_path );
 936
 937     msi_free( dst_name );
 938     msi_free( dst_path );
 939     return dst;
 940 }
 941
 942 static UINT ITERATE_DuplicateFiles(MSIRECORD *row, LPVOID param)
 943 {
 944     MSIPACKAGE *package = param;
 945     LPWSTR dest;
 946     LPCWSTR file_key, component;
 947     MSICOMPONENT *comp;
 948     MSIRECORD *uirow;
 949     MSIFILE *file;
 950
 951     component = MSI_RecordGetString(row,2);
 952     comp = get_loaded_component(package,component);
 953     if (!comp)
 954         return ERROR_SUCCESS;
 955
 956     if (!comp->Enabled)
 957     {
 958         TRACE("component is disabled\n");
 959         return ERROR_SUCCESS;
 960     }
 961
 962     if (comp->ActionRequest != INSTALLSTATE_LOCAL)
 963     {
 964         TRACE("Component not scheduled for installation %s\n", debugstr_w(component));
 965         comp->Action = comp->Installed;
 966         return ERROR_SUCCESS;
 967     }
 968     comp->Action = INSTALLSTATE_LOCAL;
 969
 970     file_key = MSI_RecordGetString(row,3);
 971     if (!file_key)
 972     {
 973         ERR("Unable to get file key\n");
 974         return ERROR_FUNCTION_FAILED;
 975     }
 976
 977     file = get_loaded_file( package, file_key );
 978     if (!file)
 979     {
 980         ERR("Original file unknown %s\n", debugstr_w(file_key));
 981         return ERROR_SUCCESS;
 982     }
 983
 984     dest = get_duplicate_filename( package, row, file_key, file->TargetPath );
 985     if (!dest)
 986     {
 987         WARN("Unable to get duplicate filename\n");
 988         return ERROR_SUCCESS;
 989     }
 990
 991     TRACE("Duplicating file %s to %s\n", debugstr_w(file->TargetPath), debugstr_w(dest));
 992
 993     if (!CopyFileW( file->TargetPath, dest, TRUE ))
 994     {
 995         WARN("Failed to copy file %s -> %s (%u)\n",
 996              debugstr_w(file->TargetPath), debugstr_w(dest), GetLastError());
 997     }
 998
 999     FIXME("We should track these duplicate files as well\n");
1000
1001     uirow = MSI_CreateRecord( 9 );
1002     MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString( row, 1 ) );
1003     MSI_RecordSetInteger( uirow, 6, file->FileSize );
1004     MSI_RecordSetStringW( uirow, 9, MSI_RecordGetString( row, 5 ) );
1005     ui_actiondata( package, szDuplicateFiles, uirow );
1006     msiobj_release( &uirow->hdr );
1007
1008     msi_free(dest);
1009     return ERROR_SUCCESS;
1010 }
1011
1012 UINT ACTION_DuplicateFiles(MSIPACKAGE *package)
1013 {
1014     UINT rc;
1015     MSIQUERY * view;
1016     static const WCHAR ExecSeqQuery[] =
1017         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1018          '`','D','u','p','l','i','c','a','t','e','F','i','l','e','`',0};
1019
1020     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
1021     if (rc != ERROR_SUCCESS)
1022         return ERROR_SUCCESS;
1023
1024     rc = MSI_IterateRecords(view, NULL, ITERATE_DuplicateFiles, package);
1025     msiobj_release(&view->hdr);
1026
1027     return rc;
1028 }
1029
1030 static UINT ITERATE_RemoveDuplicateFiles( MSIRECORD *row, LPVOID param )
1031 {
1032     MSIPACKAGE *package = param;
1033     LPWSTR dest;
1034     LPCWSTR file_key, component;
1035     MSICOMPONENT *comp;
1036     MSIRECORD *uirow;
1037     MSIFILE *file;
1038
1039     component = MSI_RecordGetString( row, 2 );
1040     comp = get_loaded_component( package, component );
1041     if (!comp)
1042         return ERROR_SUCCESS;
1043
1044     if (!comp->Enabled)
1045     {
1046         TRACE("component is disabled\n");
1047         return ERROR_SUCCESS;
1048     }
1049
1050     if (comp->ActionRequest != INSTALLSTATE_ABSENT)
1051     {
1052         TRACE("Component not scheduled for removal %s\n", debugstr_w(component));
1053         comp->Action = comp->Installed;
1054         return ERROR_SUCCESS;
1055     }
1056     comp->Action = INSTALLSTATE_ABSENT;
1057
1058     file_key = MSI_RecordGetString( row, 3 );
1059     if (!file_key)
1060     {
1061         ERR("Unable to get file key\n");
1062         return ERROR_FUNCTION_FAILED;
1063     }
1064
1065     file = get_loaded_file( package, file_key );
1066     if (!file)
1067     {
1068         ERR("Original file unknown %s\n", debugstr_w(file_key));
1069         return ERROR_SUCCESS;
1070     }
1071
1072     dest = get_duplicate_filename( package, row, file_key, file->TargetPath );
1073     if (!dest)
1074     {
1075         WARN("Unable to get duplicate filename\n");
1076         return ERROR_SUCCESS;
1077     }
1078
1079     TRACE("Removing duplicate %s of %s\n", debugstr_w(dest), debugstr_w(file->TargetPath));
1080
1081     if (!DeleteFileW( dest ))
1082     {
1083         WARN("Failed to delete duplicate file %s (%u)\n", debugstr_w(dest), GetLastError());
1084     }
1085
1086     uirow = MSI_CreateRecord( 9 );
1087     MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString( row, 1 ) );
1088     MSI_RecordSetStringW( uirow, 9, MSI_RecordGetString( row, 5 ) );
1089     ui_actiondata( package, szRemoveDuplicateFiles, uirow );
1090     msiobj_release( &uirow->hdr );
1091
1092     msi_free(dest);
1093     return ERROR_SUCCESS;
1094 }
1095
1096 UINT ACTION_RemoveDuplicateFiles( MSIPACKAGE *package )
1097 {
1098     UINT rc;
1099     MSIQUERY *view;
1100     static const WCHAR query[] =
1101         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1102          '`','D','u','p','l','i','c','a','t','e','F','i','l','e','`',0};
1103
1104     rc = MSI_DatabaseOpenViewW( package->db, query, &view );
1105     if (rc != ERROR_SUCCESS)
1106         return ERROR_SUCCESS;
1107
1108     rc = MSI_IterateRecords( view, NULL, ITERATE_RemoveDuplicateFiles, package );
1109     msiobj_release( &view->hdr );
1110
1111     return rc;
1112 }
1113
1114 static BOOL verify_comp_for_removal(MSICOMPONENT *comp, UINT install_mode)
1115 {
1116     INSTALLSTATE request = comp->ActionRequest;
1117
1118     /* special case */
1119     if (request != INSTALLSTATE_SOURCE &&
1120         comp->Attributes & msidbComponentAttributesSourceOnly &&
1121         (install_mode == msidbRemoveFileInstallModeOnRemove ||
1122          install_mode == msidbRemoveFileInstallModeOnBoth)) return TRUE;
1123
1124     switch (request)
1125     {
1126     case INSTALLSTATE_LOCAL:
1127     case INSTALLSTATE_SOURCE:
1128         if (install_mode == msidbRemoveFileInstallModeOnInstall ||
1129             install_mode == msidbRemoveFileInstallModeOnBoth) return TRUE;
1130         break;
1131     case INSTALLSTATE_ABSENT:
1132         if (install_mode == msidbRemoveFileInstallModeOnRemove ||
1133             install_mode == msidbRemoveFileInstallModeOnBoth) return TRUE;
1134         break;
1135     default: break;
1136     }
1137     return FALSE;
1138 }
1139
1140 static UINT ITERATE_RemoveFiles(MSIRECORD *row, LPVOID param)
1141 {
1142     MSIPACKAGE *package = param;
1143     MSICOMPONENT *comp;
1144     MSIRECORD *uirow;
1145     LPCWSTR component, dirprop;
1146     UINT install_mode;
1147     LPWSTR dir = NULL, path = NULL, filename = NULL;
1148     DWORD size;
1149     UINT ret = ERROR_SUCCESS;
1150
1151     component = MSI_RecordGetString(row, 2);
1152     dirprop = MSI_RecordGetString(row, 4);
1153     install_mode = MSI_RecordGetInteger(row, 5);
1154
1155     comp = get_loaded_component(package, component);
1156     if (!comp->Enabled)
1157     {
1158         TRACE("component is disabled\n");
1159         return ERROR_SUCCESS;
1160     }
1161
1162     if (!verify_comp_for_removal(comp, install_mode))
1163     {
1164         TRACE("Skipping removal due to install mode\n");
1165         comp->Action = comp->Installed;
1166         return ERROR_SUCCESS;
1167     }
1168
1169     if (comp->Attributes & msidbComponentAttributesPermanent)
1170     {
1171         TRACE("permanent component, not removing file\n");
1172         return ERROR_SUCCESS;
1173     }
1174
1175     dir = msi_dup_property(package->db, dirprop);
1176     if (!dir)
1177         return ERROR_OUTOFMEMORY;
1178
1179     size = 0;
1180     if ((filename = strdupW( MSI_RecordGetString(row, 3) )))
1181     {
1182         reduce_to_longfilename( filename );
1183         size = lstrlenW( filename );
1184     }
1185     size += lstrlenW(dir) + 2;
1186     path = msi_alloc(size * sizeof(WCHAR));
1187     if (!path)
1188     {
1189         ret = ERROR_OUTOFMEMORY;
1190         goto done;
1191     }
1192
1193     if (filename)
1194     {
1195         lstrcpyW(path, dir);
1196         PathAddBackslashW(path);
1197         lstrcatW(path, filename);
1198
1199         TRACE("Deleting misc file: %s\n", debugstr_w(path));
1200         DeleteFileW(path);
1201     }
1202     else
1203     {
1204         TRACE("Removing misc directory: %s\n", debugstr_w(dir));
1205         RemoveDirectoryW(dir);
1206     }
1207
1208 done:
1209     uirow = MSI_CreateRecord( 9 );
1210     MSI_RecordSetStringW( uirow, 1, MSI_RecordGetString(row, 1) );
1211     MSI_RecordSetStringW( uirow, 9, dir );
1212     ui_actiondata( package, szRemoveFiles, uirow );
1213     msiobj_release( &uirow->hdr );
1214
1215     msi_free(filename);
1216     msi_free(path);
1217     msi_free(dir);
1218     return ret;
1219 }
1220
1221 static BOOL has_persistent_dir( MSIPACKAGE *package, MSICOMPONENT *comp )
1222 {
1223     MSIQUERY *view;
1224     UINT r = ERROR_FUNCTION_FAILED;
1225
1226     static const WCHAR query[] = {
1227         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1228         '`','C','r','e','a','t','e','F','o','l','d','e','r','`',' ','W','H','E','R','E',' ',
1229         '`','C','o','m','p','o','n','e','n','t','_','`',' ','=','\'','%','s','\'',' ','A','N','D',' ',
1230         '`','D','i','r','e','c','t','o','r','y','_','`',' ','=','\'','%','s','\'',0};
1231
1232     if (!MSI_OpenQuery( package->db, &view, query, comp->Component, comp->Directory ))
1233     {
1234         if (!MSI_ViewExecute( view, NULL ))
1235         {
1236             MSIRECORD *rec;
1237             if (!(r = MSI_ViewFetch( view, &rec )))
1238             {
1239                 TRACE("directory %s is persistent\n", debugstr_w(comp->Directory));
1240                 msiobj_release( &rec->hdr );
1241             }
1242         }
1243         msiobj_release( &view->hdr );
1244     }
1245     return (r == ERROR_SUCCESS);
1246 }
1247
1248 UINT ACTION_RemoveFiles( MSIPACKAGE *package )
1249 {
1250     MSIQUERY *view;
1251     MSIFILE *file;
1252     UINT r;
1253
1254     static const WCHAR query[] = {
1255         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
1256         '`','R','e','m','o','v','e','F','i','l','e','`',0};
1257
1258     r = MSI_DatabaseOpenViewW(package->db, query, &view);
1259     if (r == ERROR_SUCCESS)
1260     {
1261         MSI_IterateRecords(view, NULL, ITERATE_RemoveFiles, package);
1262         msiobj_release(&view->hdr);
1263     }
1264
1265     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
1266     {
1267         MSIRECORD *uirow;
1268         LPWSTR dir, p;
1269         VS_FIXEDFILEINFO *ver;
1270
1271         if ( file->state == msifs_installed )
1272             ERR("removing installed file %s\n", debugstr_w(file->TargetPath));
1273
1274         if ( file->Component->ActionRequest != INSTALLSTATE_ABSENT ||
1275              file->Component->Installed == INSTALLSTATE_SOURCE )
1276             continue;
1277
1278         if (!file->Component->Enabled)
1279         {
1280             TRACE("component is disabled\n");
1281             continue;
1282         }
1283
1284         if (file->Component->Attributes & msidbComponentAttributesPermanent)
1285         {
1286             TRACE("permanent component, not removing file\n");
1287             continue;
1288         }
1289
1290         if (file->Version)
1291         {
1292             ver = msi_get_disk_file_version( file->TargetPath );
1293             if (ver && msi_compare_file_versions( ver, file->Version ) > 0)
1294             {
1295                 TRACE("newer version detected, not removing file\n");
1296                 msi_free( ver );
1297                 continue;
1298             }
1299             msi_free( ver );
1300         }
1301
1302         TRACE("removing %s\n", debugstr_w(file->File) );
1303
1304         SetFileAttributesW( file->TargetPath, FILE_ATTRIBUTE_NORMAL );
1305         if (!DeleteFileW( file->TargetPath ))
1306         {
1307             WARN("failed to delete %s (%u)\n",  debugstr_w(file->TargetPath), GetLastError());
1308         }
1309         else if (!has_persistent_dir( package, file->Component ))
1310         {
1311             if ((dir = strdupW( file->TargetPath )))
1312             {
1313                 if ((p = strrchrW( dir, '\\' ))) *p = 0;
1314                 RemoveDirectoryW( dir );
1315                 msi_free( dir );
1316             }
1317         }
1318         file->state = msifs_missing;
1319
1320         uirow = MSI_CreateRecord( 9 );
1321         MSI_RecordSetStringW( uirow, 1, file->FileName );
1322         MSI_RecordSetStringW( uirow, 9, file->Component->Directory );
1323         ui_actiondata( package, szRemoveFiles, uirow );
1324         msiobj_release( &uirow->hdr );
1325         /* FIXME: call ui_progress here? */
1326     }
1327
1328     return ERROR_SUCCESS;
1329 }