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