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