dlls/msi/files.c

   1 /*
   2  * Implementation of the Microsoft Installer (msi.dll)
   3  *
   4  * Copyright 2005 Aric Stewart for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21
  22 /*
  23  * Actions dealing with files These are
  24  *
  25  * InstallFiles
  26  * DuplicateFiles
  27  * MoveFiles (TODO)
  28  * PatchFiles (TODO)
  29  * RemoveDuplicateFiles(TODO)
  30  * RemoveFiles(TODO)
  31  */
  32
  33 #include <stdarg.h>
  34
  35 #include "windef.h"
  36 #include "winbase.h"
  37 #include "winerror.h"
  38 #include "wine/debug.h"
  39 #include "fdi.h"
  40 #include "msi.h"
  41 #include "msidefs.h"
  42 #include "msipriv.h"
  43 #include "winuser.h"
  44 #include "winreg.h"
  45 #include "shlwapi.h"
  46 #include "wine/unicode.h"
  47
  48 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  49
  50 static void msi_file_update_ui( MSIPACKAGE *package, MSIFILE *f, const WCHAR *action )
  51 {
  52     MSIRECORD *uirow;
  53     LPWSTR uipath, p;
  54
  55     /* the UI chunk */
  56     uirow = MSI_CreateRecord( 9 );
  57     MSI_RecordSetStringW( uirow, 1, f->FileName );
  58     uipath = strdupW( f->TargetPath );
  59     p = strrchrW(uipath,'\\');
  60     if (p)
  61         p[1]=0;
  62     MSI_RecordSetStringW( uirow, 9, uipath);
  63     MSI_RecordSetInteger( uirow, 6, f->FileSize );
  64     ui_actiondata( package, action, uirow);
  65     msiobj_release( &uirow->hdr );
  66     msi_free( uipath );
  67     ui_progress( package, 2, f->FileSize, 0, 0);
  68 }
  69
  70 /* compares the version of a file read from the filesystem and
  71  * the version specified in the File table
  72  */
  73 static int msi_compare_file_version(MSIFILE *file)
  74 {
  75     WCHAR version[MAX_PATH];
  76     DWORD size;
  77     UINT r;
  78
  79     size = MAX_PATH;
  80     version[0] = '\0';
  81     r = MsiGetFileVersionW(file->TargetPath, version, &size, NULL, NULL);
  82     if (r != ERROR_SUCCESS)
  83         return 0;
  84
  85     return lstrcmpW(version, file->Version);
  86 }
  87
  88 static UINT get_file_target(MSIPACKAGE *package, LPCWSTR file_key,
  89                             MSIFILE** file)
  90 {
  91     LIST_FOR_EACH_ENTRY( *file, &package->files, MSIFILE, entry )
  92     {
  93         if (lstrcmpW( file_key, (*file)->File )==0)
  94         {
  95             if ((*file)->state >= msifs_overwrite)
  96                 return ERROR_SUCCESS;
  97             else
  98                 return ERROR_FILE_NOT_FOUND;
  99         }
 100     }
 101
 102     return ERROR_FUNCTION_FAILED;
 103 }
 104
 105 static void schedule_install_files(MSIPACKAGE *package)
 106 {
 107     MSIFILE *file;
 108
 109     LIST_FOR_EACH_ENTRY(file, &package->files, MSIFILE, entry)
 110     {
 111         if (!ACTION_VerifyComponentForAction(file->Component, INSTALLSTATE_LOCAL))
 112         {
 113             TRACE("File %s is not scheduled for install\n", debugstr_w(file->File));
 114
 115             ui_progress(package,2,file->FileSize,0,0);
 116             file->state = msifs_skipped;
 117         }
 118     }
 119 }
 120
 121 static UINT copy_file(MSIFILE *file, LPWSTR source)
 122 {
 123     BOOL ret;
 124
 125     ret = CopyFileW(source, file->TargetPath, FALSE);
 126     if (!ret)
 127         return GetLastError();
 128
 129     SetFileAttributesW(file->TargetPath, FILE_ATTRIBUTE_NORMAL);
 130
 131     file->state = msifs_installed;
 132     return ERROR_SUCCESS;
 133 }
 134
 135 static UINT copy_install_file(MSIPACKAGE *package, MSIFILE *file, LPWSTR source)
 136 {
 137     UINT gle;
 138
 139     TRACE("Copying %s to %s\n", debugstr_w(source),
 140           debugstr_w(file->TargetPath));
 141
 142     gle = copy_file(file, source);
 143     if (gle == ERROR_SUCCESS)
 144         return gle;
 145
 146     if (gle == ERROR_ALREADY_EXISTS && file->state == msifs_overwrite)
 147     {
 148         TRACE("overwriting existing file\n");
 149         return ERROR_SUCCESS;
 150     }
 151     else if (gle == ERROR_ACCESS_DENIED)
 152     {
 153         SetFileAttributesW(file->TargetPath, FILE_ATTRIBUTE_NORMAL);
 154
 155         gle = copy_file(file, source);
 156         TRACE("Overwriting existing file: %d\n", gle);
 157     }
 158     if (gle == ERROR_SHARING_VIOLATION || gle == ERROR_USER_MAPPED_FILE)
 159     {
 160         WCHAR tmpfileW[MAX_PATH], *pathW, *p;
 161         DWORD len;
 162
 163         TRACE("file in use, scheduling rename operation\n");
 164
 165         GetTempFileNameW(szBackSlash, szMsi, 0, tmpfileW);
 166         len = strlenW(file->TargetPath) + strlenW(tmpfileW) + 1;
 167         if (!(pathW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
 168             return ERROR_OUTOFMEMORY;
 169
 170         strcpyW(pathW, file->TargetPath);
 171         if ((p = strrchrW(pathW, '\\'))) *p = 0;
 172         strcatW(pathW, tmpfileW);
 173
 174         if (CopyFileW(source, pathW, FALSE) &&
 175             MoveFileExW(file->TargetPath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT) &&
 176             MoveFileExW(pathW, file->TargetPath, MOVEFILE_DELAY_UNTIL_REBOOT))
 177         {
 178             file->state = msifs_installed;
 179             package->need_reboot = 1;
 180             gle = ERROR_SUCCESS;
 181         }
 182         else
 183         {
 184             gle = GetLastError();
 185             WARN("failed to schedule rename operation: %d)\n", gle);
 186         }
 187         HeapFree(GetProcessHeap(), 0, pathW);
 188     }
 189
 190     return gle;
 191 }
 192
 193 static BOOL check_dest_hash_matches(MSIFILE *file)
 194 {
 195     MSIFILEHASHINFO hash;
 196     UINT r;
 197
 198     if (!file->hash.dwFileHashInfoSize)
 199         return FALSE;
 200
 201     hash.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
 202     r = MsiGetFileHashW(file->TargetPath, 0, &hash);
 203     if (r != ERROR_SUCCESS)
 204         return FALSE;
 205
 206     return !memcmp(&hash, &file->hash, sizeof(MSIFILEHASHINFO));
 207 }
 208
 209 static BOOL installfiles_cb(MSIPACKAGE *package, LPCWSTR file, DWORD action,
 210                             LPWSTR *path, DWORD *attrs, PVOID user)
 211 {
 212     static MSIFILE *f = NULL;
 213
 214     if (action == MSICABEXTRACT_BEGINEXTRACT)
 215     {
 216         f = get_loaded_file(package, file);
 217         if (!f)
 218         {
 219             WARN("unknown file in cabinet (%s)\n", debugstr_w(file));
 220             return FALSE;
 221         }
 222
 223         if (f->state != msifs_missing && f->state != msifs_overwrite)
 224         {
 225             TRACE("Skipping extraction of %s\n", debugstr_w(file));
 226             return FALSE;
 227         }
 228
 229         msi_file_update_ui(package, f, szInstallFiles);
 230
 231         *path = strdupW(f->TargetPath);
 232         *attrs = f->Attributes;
 233     }
 234     else if (action == MSICABEXTRACT_FILEEXTRACTED)
 235     {
 236         f->state = msifs_installed;
 237         f = NULL;
 238     }
 239
 240     return TRUE;
 241 }
 242
 243 /*
 244  * ACTION_InstallFiles()
 245  *
 246  * For efficiency, this is done in two passes:
 247  * 1) Correct all the TargetPaths and determine what files are to be installed.
 248  * 2) Extract Cabinets and copy files.
 249  */
 250 UINT ACTION_InstallFiles(MSIPACKAGE *package)
 251 {
 252     MSIMEDIAINFO *mi;
 253     UINT rc = ERROR_SUCCESS;
 254     MSIFILE *file;
 255
 256     /* increment progress bar each time action data is sent */
 257     ui_progress(package,1,1,0,0);
 258
 259     schedule_install_files(package);
 260
 261     /*
 262      * Despite MSDN specifying that the CreateFolders action
 263      * should be called before InstallFiles, some installers don't
 264      * do that, and they seem to work correctly.  We need to create
 265      * directories here to make sure that the files can be copied.
 266      */
 267     msi_create_component_directories( package );
 268
 269     mi = msi_alloc_zero( sizeof(MSIMEDIAINFO) );
 270
 271     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
 272     {
 273         if (file->state != msifs_missing && !mi->is_continuous && file->state != msifs_overwrite)
 274             continue;
 275
 276         if (check_dest_hash_matches(file))
 277         {
 278             TRACE("File hashes match, not overwriting\n");
 279             continue;
 280         }
 281
 282         if (MsiGetFileVersionW(file->TargetPath, NULL, NULL, NULL, NULL) == ERROR_SUCCESS &&
 283             msi_compare_file_version(file) >= 0)
 284         {
 285             TRACE("Destination file version greater, not overwriting\n");
 286             continue;
 287         }
 288
 289         if (file->Sequence > mi->last_sequence || mi->is_continuous ||
 290             (file->IsCompressed && !mi->is_extracted))
 291         {
 292             MSICABDATA data;
 293
 294             rc = ready_media(package, file, mi);
 295             if (rc != ERROR_SUCCESS)
 296             {
 297                 ERR("Failed to ready media\n");
 298                 break;
 299             }
 300
 301             data.mi = mi;
 302             data.package = package;
 303             data.cb = installfiles_cb;
 304             data.user = NULL;
 305
 306             if (file->IsCompressed &&
 307                 !msi_cabextract(package, mi, &data))
 308             {
 309                 ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
 310                 rc = ERROR_FUNCTION_FAILED;
 311                 break;
 312             }
 313         }
 314
 315         if (!file->IsCompressed)
 316         {
 317             LPWSTR source = resolve_file_source(package, file);
 318
 319             TRACE("file paths %s to %s\n", debugstr_w(source),
 320                   debugstr_w(file->TargetPath));
 321
 322             msi_file_update_ui(package, file, szInstallFiles);
 323             rc = copy_install_file(package, file, source);
 324             if (rc != ERROR_SUCCESS)
 325             {
 326                 ERR("Failed to copy %s to %s (%d)\n", debugstr_w(source),
 327                     debugstr_w(file->TargetPath), rc);
 328                 rc = ERROR_INSTALL_FAILURE;
 329                 msi_free(source);
 330                 break;
 331             }
 332
 333             msi_free(source);
 334         }
 335         else if (file->state != msifs_installed)
 336         {
 337             ERR("compressed file wasn't extracted (%s)\n",
 338                 debugstr_w(file->TargetPath));
 339             rc = ERROR_INSTALL_FAILURE;
 340             break;
 341         }
 342     }
 343
 344     msi_free_media_info(mi);
 345     return rc;
 346 }
 347
 348 static UINT ITERATE_DuplicateFiles(MSIRECORD *row, LPVOID param)
 349 {
 350     MSIPACKAGE *package = param;
 351     WCHAR dest_name[0x100];
 352     LPWSTR dest_path, dest;
 353     LPCWSTR file_key, component;
 354     DWORD sz;
 355     DWORD rc;
 356     MSICOMPONENT *comp;
 357     MSIFILE *file;
 358
 359     component = MSI_RecordGetString(row,2);
 360     comp = get_loaded_component(package,component);
 361
 362     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ))
 363     {
 364         TRACE("Skipping copy due to disabled component %s\n",
 365                         debugstr_w(component));
 366
 367         /* the action taken was the same as the current install state */
 368         comp->Action = comp->Installed;
 369
 370         return ERROR_SUCCESS;
 371     }
 372
 373     comp->Action = INSTALLSTATE_LOCAL;
 374
 375     file_key = MSI_RecordGetString(row,3);
 376     if (!file_key)
 377     {
 378         ERR("Unable to get file key\n");
 379         return ERROR_FUNCTION_FAILED;
 380     }
 381
 382     rc = get_file_target(package,file_key,&file);
 383
 384     if (rc != ERROR_SUCCESS)
 385     {
 386         ERR("Original file unknown %s\n",debugstr_w(file_key));
 387         return ERROR_SUCCESS;
 388     }
 389
 390     if (MSI_RecordIsNull(row,4))
 391         strcpyW(dest_name,strrchrW(file->TargetPath,'\\')+1);
 392     else
 393     {
 394         sz=0x100;
 395         MSI_RecordGetStringW(row,4,dest_name,&sz);
 396         reduce_to_longfilename(dest_name);
 397     }
 398
 399     if (MSI_RecordIsNull(row,5))
 400     {
 401         LPWSTR p;
 402         dest_path = strdupW(file->TargetPath);
 403         p = strrchrW(dest_path,'\\');
 404         if (p)
 405             *p=0;
 406     }
 407     else
 408     {
 409         LPCWSTR destkey;
 410         destkey = MSI_RecordGetString(row,5);
 411         dest_path = resolve_folder(package, destkey, FALSE, FALSE, TRUE, NULL);
 412         if (!dest_path)
 413         {
 414             /* try a Property */
 415             dest_path = msi_dup_property( package, destkey );
 416             if (!dest_path)
 417             {
 418                 FIXME("Unable to get destination folder, try AppSearch properties\n");
 419                 return ERROR_SUCCESS;
 420             }
 421         }
 422     }
 423
 424     dest = build_directory_name(2, dest_path, dest_name);
 425     create_full_pathW(dest_path);
 426
 427     TRACE("Duplicating file %s to %s\n",debugstr_w(file->TargetPath),
 428                     debugstr_w(dest));
 429
 430     if (strcmpW(file->TargetPath,dest))
 431         rc = !CopyFileW(file->TargetPath,dest,TRUE);
 432     else
 433         rc = ERROR_SUCCESS;
 434
 435     if (rc != ERROR_SUCCESS)
 436         ERR("Failed to copy file %s -> %s, last error %d\n",
 437             debugstr_w(file->TargetPath), debugstr_w(dest_path), GetLastError());
 438
 439     FIXME("We should track these duplicate files as well\n");
 440
 441     msi_free(dest_path);
 442     msi_free(dest);
 443
 444     msi_file_update_ui(package, file, szDuplicateFiles);
 445
 446     return ERROR_SUCCESS;
 447 }
 448
 449 UINT ACTION_DuplicateFiles(MSIPACKAGE *package)
 450 {
 451     UINT rc;
 452     MSIQUERY * view;
 453     static const WCHAR ExecSeqQuery[] =
 454         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 455          '`','D','u','p','l','i','c','a','t','e','F','i','l','e','`',0};
 456
 457     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 458     if (rc != ERROR_SUCCESS)
 459         return ERROR_SUCCESS;
 460
 461     rc = MSI_IterateRecords(view, NULL, ITERATE_DuplicateFiles, package);
 462     msiobj_release(&view->hdr);
 463
 464     return rc;
 465 }
 466
 467 static BOOL verify_comp_for_removal(MSICOMPONENT *comp, UINT install_mode)
 468 {
 469     INSTALLSTATE request = comp->ActionRequest;
 470
 471     if (request == INSTALLSTATE_UNKNOWN)
 472         return FALSE;
 473
 474     if (install_mode == msidbRemoveFileInstallModeOnInstall &&
 475         (request == INSTALLSTATE_LOCAL || request == INSTALLSTATE_SOURCE))
 476         return TRUE;
 477
 478     if (request == INSTALLSTATE_ABSENT)
 479     {
 480         if (!comp->ComponentId)
 481             return FALSE;
 482
 483         if (install_mode == msidbRemoveFileInstallModeOnRemove)
 484             return TRUE;
 485     }
 486
 487     if (install_mode == msidbRemoveFileInstallModeOnBoth)
 488         return TRUE;
 489
 490     return FALSE;
 491 }
 492
 493 static UINT ITERATE_RemoveFiles(MSIRECORD *row, LPVOID param)
 494 {
 495     MSIPACKAGE *package = param;
 496     MSICOMPONENT *comp;
 497     LPCWSTR component, filename, dirprop;
 498     UINT install_mode;
 499     LPWSTR dir = NULL, path = NULL;
 500     DWORD size;
 501     UINT r;
 502
 503     component = MSI_RecordGetString(row, 2);
 504     filename = MSI_RecordGetString(row, 3);
 505     dirprop = MSI_RecordGetString(row, 4);
 506     install_mode = MSI_RecordGetInteger(row, 5);
 507
 508     comp = get_loaded_component(package, component);
 509     if (!comp)
 510     {
 511         ERR("Invalid component: %s\n", debugstr_w(component));
 512         return ERROR_FUNCTION_FAILED;
 513     }
 514
 515     if (!verify_comp_for_removal(comp, install_mode))
 516     {
 517         TRACE("Skipping removal due to missing conditions\n");
 518         comp->Action = comp->Installed;
 519         return ERROR_SUCCESS;
 520     }
 521
 522     dir = msi_dup_property(package, dirprop);
 523     if (!dir)
 524         return ERROR_OUTOFMEMORY;
 525
 526     size = (filename != NULL) ? lstrlenW(filename) : 0;
 527     size += lstrlenW(dir) + 2;
 528     path = msi_alloc(size * sizeof(WCHAR));
 529     if (!path)
 530     {
 531         r = ERROR_OUTOFMEMORY;
 532         goto done;
 533     }
 534
 535     lstrcpyW(path, dir);
 536     PathAddBackslashW(path);
 537
 538     if (filename)
 539     {
 540         lstrcatW(path, filename);
 541
 542         TRACE("Deleting misc file: %s\n", debugstr_w(path));
 543         DeleteFileW(path);
 544     }
 545     else
 546     {
 547         TRACE("Removing misc directory: %s\n", debugstr_w(path));
 548         RemoveDirectoryW(path);
 549     }
 550
 551 done:
 552     msi_free(path);
 553     msi_free(dir);
 554     return ERROR_SUCCESS;
 555 }
 556
 557 UINT ACTION_RemoveFiles( MSIPACKAGE *package )
 558 {
 559     MSIQUERY *view;
 560     MSIFILE *file;
 561     UINT r;
 562
 563     static const WCHAR query[] = {
 564         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 565         '`','R','e','m','o','v','e','F','i','l','e','`',0};
 566
 567     r = MSI_DatabaseOpenViewW(package->db, query, &view);
 568     if (r == ERROR_SUCCESS)
 569     {
 570         MSI_IterateRecords(view, NULL, ITERATE_RemoveFiles, package);
 571         msiobj_release(&view->hdr);
 572     }
 573
 574     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
 575     {
 576         MSIRECORD *uirow;
 577         LPWSTR uipath, p;
 578
 579         if ( file->state == msifs_installed )
 580             ERR("removing installed file %s\n", debugstr_w(file->TargetPath));
 581
 582         if ( file->Component->ActionRequest != INSTALLSTATE_ABSENT ||
 583              file->Component->Installed == INSTALLSTATE_SOURCE )
 584             continue;
 585
 586         /* don't remove a file if the old file
 587          * is strictly newer than the version to be installed
 588          */
 589         if ( msi_compare_file_version( file ) < 0 )
 590             continue;
 591
 592         TRACE("removing %s\n", debugstr_w(file->File) );
 593         if ( !DeleteFileW( file->TargetPath ) )
 594             TRACE("failed to delete %s\n",  debugstr_w(file->TargetPath));
 595         file->state = msifs_missing;
 596
 597         /* the UI chunk */
 598         uirow = MSI_CreateRecord( 9 );
 599         MSI_RecordSetStringW( uirow, 1, file->FileName );
 600         uipath = strdupW( file->TargetPath );
 601         p = strrchrW(uipath,'\\');
 602         if (p)
 603             p[1]=0;
 604         MSI_RecordSetStringW( uirow, 9, uipath);
 605         ui_actiondata( package, szRemoveFiles, uirow);
 606         msiobj_release( &uirow->hdr );
 607         msi_free( uipath );
 608         /* FIXME: call ui_progress here? */
 609     }
 610
 611     return ERROR_SUCCESS;
 612 }