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