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 "msvcrt/fcntl.h"
  43 #include "msipriv.h"
  44 #include "winuser.h"
  45 #include "winreg.h"
  46 #include "shlwapi.h"
  47 #include "wine/unicode.h"
  48
  49 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  50
  51 extern const WCHAR szInstallFiles[];
  52 extern const WCHAR szDuplicateFiles[];
  53 extern const WCHAR szMoveFiles[];
  54 extern const WCHAR szPatchFiles[];
  55 extern const WCHAR szRemoveDuplicateFiles[];
  56 extern const WCHAR szRemoveFiles[];
  57
  58 static const WCHAR cszTempFolder[]= {'T','e','m','p','F','o','l','d','e','r',0};
  59
  60 struct media_info {
  61     UINT disk_id;
  62     UINT type;
  63     UINT last_sequence;
  64     LPWSTR disk_prompt;
  65     LPWSTR cabinet;
  66     LPWSTR first_volume;
  67     LPWSTR volume_label;
  68     BOOL is_continuous;
  69     BOOL is_extracted;
  70     WCHAR source[MAX_PATH];
  71 };
  72
  73 static BOOL source_matches_volume(struct media_info *mi, LPWSTR source_root)
  74 {
  75     WCHAR volume_name[MAX_PATH + 1];
  76
  77     if (!GetVolumeInformationW(source_root, volume_name, MAX_PATH + 1,
  78                                NULL, NULL, NULL, NULL, 0))
  79     {
  80         ERR("Failed to get volume information\n");
  81         return FALSE;
  82     }
  83
  84     return !lstrcmpW(mi->volume_label, volume_name);
  85 }
  86
  87 static UINT msi_change_media( MSIPACKAGE *package, struct media_info *mi )
  88 {
  89     LPSTR msg;
  90     LPWSTR error, error_dialog;
  91     LPWSTR source_dir;
  92     UINT r = ERROR_SUCCESS;
  93
  94     static const WCHAR szUILevel[] = {'U','I','L','e','v','e','l',0};
  95     static const WCHAR error_prop[] = {'E','r','r','o','r','D','i','a','l','o','g',0};
  96
  97     if ( (msi_get_property_int(package, szUILevel, 0) & INSTALLUILEVEL_MASK) == INSTALLUILEVEL_NONE && !gUIHandlerA )
  98         return ERROR_SUCCESS;
  99
 100     error = generate_error_string( package, 1302, 1, mi->disk_prompt );
 101     error_dialog = msi_dup_property( package, error_prop );
 102     source_dir = msi_dup_property( package, cszSourceDir );
 103     PathStripToRootW(source_dir);
 104
 105     while ( r == ERROR_SUCCESS &&
 106             !source_matches_volume(mi, source_dir) )
 107     {
 108         r = msi_spawn_error_dialog( package, error_dialog, error );
 109
 110         if (gUIHandlerA)
 111         {
 112             msg = strdupWtoA( error );
 113             gUIHandlerA( gUIContext, MB_RETRYCANCEL | INSTALLMESSAGE_ERROR, msg );
 114             msi_free(msg);
 115         }
 116     }
 117
 118     msi_free( error );
 119     msi_free( error_dialog );
 120     msi_free( source_dir );
 121
 122     return r;
 123 }
 124
 125 /*
 126  * This is a helper function for handling embedded cabinet media
 127  */
 128 static UINT writeout_cabinet_stream(MSIPACKAGE *package, LPCWSTR stream_name,
 129                                     WCHAR* source)
 130 {
 131     UINT rc;
 132     USHORT* data;
 133     UINT    size;
 134     DWORD   write;
 135     HANDLE  the_file;
 136     WCHAR tmp[MAX_PATH];
 137
 138     rc = read_raw_stream_data(package->db,stream_name,&data,&size);
 139     if (rc != ERROR_SUCCESS)
 140         return rc;
 141
 142     write = MAX_PATH;
 143     if (MSI_GetPropertyW(package, cszTempFolder, tmp, &write))
 144         GetTempPathW(MAX_PATH,tmp);
 145
 146     GetTempFileNameW(tmp,stream_name,0,source);
 147
 148     track_tempfile(package, source);
 149     the_file = CreateFileW(source, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 150                            FILE_ATTRIBUTE_NORMAL, NULL);
 151
 152     if (the_file == INVALID_HANDLE_VALUE)
 153     {
 154         ERR("Unable to create file %s\n",debugstr_w(source));
 155         rc = ERROR_FUNCTION_FAILED;
 156         goto end;
 157     }
 158
 159     WriteFile(the_file,data,size,&write,NULL);
 160     CloseHandle(the_file);
 161     TRACE("wrote %i bytes to %s\n",write,debugstr_w(source));
 162 end:
 163     msi_free(data);
 164     return rc;
 165 }
 166
 167
 168 /* Support functions for FDI functions */
 169 typedef struct
 170 {
 171     MSIPACKAGE* package;
 172     struct media_info *mi;
 173 } CabData;
 174
 175 static void * cabinet_alloc(ULONG cb)
 176 {
 177     return msi_alloc(cb);
 178 }
 179
 180 static void cabinet_free(void *pv)
 181 {
 182     msi_free(pv);
 183 }
 184
 185 static INT_PTR cabinet_open(char *pszFile, int oflag, int pmode)
 186 {
 187     HANDLE handle;
 188     DWORD dwAccess = 0;
 189     DWORD dwShareMode = 0;
 190     DWORD dwCreateDisposition = OPEN_EXISTING;
 191     switch (oflag & _O_ACCMODE)
 192     {
 193     case _O_RDONLY:
 194         dwAccess = GENERIC_READ;
 195         dwShareMode = FILE_SHARE_READ | FILE_SHARE_DELETE;
 196         break;
 197     case _O_WRONLY:
 198         dwAccess = GENERIC_WRITE;
 199         dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
 200         break;
 201     case _O_RDWR:
 202         dwAccess = GENERIC_READ | GENERIC_WRITE;
 203         dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
 204         break;
 205     }
 206     if ((oflag & (_O_CREAT | _O_EXCL)) == (_O_CREAT | _O_EXCL))
 207         dwCreateDisposition = CREATE_NEW;
 208     else if (oflag & _O_CREAT)
 209         dwCreateDisposition = CREATE_ALWAYS;
 210     handle = CreateFileA( pszFile, dwAccess, dwShareMode, NULL,
 211                           dwCreateDisposition, 0, NULL );
 212     if (handle == INVALID_HANDLE_VALUE)
 213         return 0;
 214     return (INT_PTR) handle;
 215 }
 216
 217 static UINT cabinet_read(INT_PTR hf, void *pv, UINT cb)
 218 {
 219     HANDLE handle = (HANDLE) hf;
 220     DWORD dwRead;
 221     if (ReadFile(handle, pv, cb, &dwRead, NULL))
 222         return dwRead;
 223     return 0;
 224 }
 225
 226 static UINT cabinet_write(INT_PTR hf, void *pv, UINT cb)
 227 {
 228     HANDLE handle = (HANDLE) hf;
 229     DWORD dwWritten;
 230     if (WriteFile(handle, pv, cb, &dwWritten, NULL))
 231         return dwWritten;
 232     return 0;
 233 }
 234
 235 static int cabinet_close(INT_PTR hf)
 236 {
 237     HANDLE handle = (HANDLE) hf;
 238     return CloseHandle(handle) ? 0 : -1;
 239 }
 240
 241 static long cabinet_seek(INT_PTR hf, long dist, int seektype)
 242 {
 243     HANDLE handle = (HANDLE) hf;
 244     /* flags are compatible and so are passed straight through */
 245     return SetFilePointer(handle, dist, NULL, seektype);
 246 }
 247
 248 static void msi_file_update_ui( MSIPACKAGE *package, MSIFILE *f, const WCHAR *action )
 249 {
 250     MSIRECORD *uirow;
 251     LPWSTR uipath, p;
 252
 253     /* the UI chunk */
 254     uirow = MSI_CreateRecord( 9 );
 255     MSI_RecordSetStringW( uirow, 1, f->FileName );
 256     uipath = strdupW( f->TargetPath );
 257     p = strrchrW(uipath,'\\');
 258     if (p)
 259         p[1]=0;
 260     MSI_RecordSetStringW( uirow, 9, uipath);
 261     MSI_RecordSetInteger( uirow, 6, f->FileSize );
 262     ui_actiondata( package, action, uirow);
 263     msiobj_release( &uirow->hdr );
 264     msi_free( uipath );
 265     ui_progress( package, 2, f->FileSize, 0, 0);
 266 }
 267
 268 static UINT msi_media_get_disk_info( MSIPACKAGE *package, struct media_info *mi )
 269 {
 270     MSIRECORD *row;
 271     LPWSTR ptr;
 272
 273     static const WCHAR query[] =
 274         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
 275          '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
 276          '`','D','i','s','k','I','d','`',' ','=',' ','%','i',0};
 277
 278     row = MSI_QueryGetRecord(package->db, query, mi->disk_id);
 279     if (!row)
 280     {
 281         TRACE("Unable to query row\n");
 282         return ERROR_FUNCTION_FAILED;
 283     }
 284
 285     mi->disk_prompt = strdupW(MSI_RecordGetString(row, 3));
 286     mi->cabinet = strdupW(MSI_RecordGetString(row, 4));
 287     mi->volume_label = strdupW(MSI_RecordGetString(row, 5));
 288
 289     if (!mi->first_volume)
 290         mi->first_volume = strdupW(mi->volume_label);
 291
 292     ptr = strrchrW(mi->source, '\\') + 1;
 293     lstrcpyW(ptr, mi->cabinet);
 294     msiobj_release(&row->hdr);
 295
 296     return ERROR_SUCCESS;
 297 }
 298
 299 static INT_PTR cabinet_notify(FDINOTIFICATIONTYPE fdint, PFDINOTIFICATION pfdin)
 300 {
 301     TRACE("(%d)\n", fdint);
 302
 303     switch (fdint)
 304     {
 305     case fdintPARTIAL_FILE:
 306     {
 307         CabData *data = (CabData *)pfdin->pv;
 308         data->mi->is_continuous = FALSE;
 309         return 0;
 310     }
 311     case fdintNEXT_CABINET:
 312     {
 313         CabData *data = (CabData *)pfdin->pv;
 314         struct media_info *mi = data->mi;
 315         LPWSTR cab = strdupAtoW(pfdin->psz1);
 316         UINT rc;
 317
 318         msi_free(mi->disk_prompt);
 319         msi_free(mi->cabinet);
 320         msi_free(mi->volume_label);
 321         mi->disk_prompt = NULL;
 322         mi->cabinet = NULL;
 323         mi->volume_label = NULL;
 324
 325         mi->disk_id++;
 326         mi->is_continuous = TRUE;
 327
 328         rc = msi_media_get_disk_info(data->package, mi);
 329         if (rc != ERROR_SUCCESS)
 330         {
 331             msi_free(cab);
 332             ERR("Failed to get next cabinet information: %d\n", rc);
 333             return -1;
 334         }
 335
 336         if (lstrcmpiW(mi->cabinet, cab))
 337         {
 338             msi_free(cab);
 339             ERR("Continuous cabinet does not match the next cabinet in the Media table\n");
 340             return -1;
 341         }
 342
 343         msi_free(cab);
 344
 345         TRACE("Searching for %s\n", debugstr_w(mi->source));
 346
 347         if (GetFileAttributesW(mi->source) == INVALID_FILE_ATTRIBUTES)
 348             rc = msi_change_media(data->package, mi);
 349
 350         if (rc != ERROR_SUCCESS)
 351             return -1;
 352
 353         return 0;
 354     }
 355     case fdintCOPY_FILE:
 356     {
 357         CabData *data = (CabData*) pfdin->pv;
 358         HANDLE handle;
 359         LPWSTR file;
 360         MSIFILE *f;
 361         DWORD attrs;
 362
 363         file = strdupAtoW(pfdin->psz1);
 364         f = get_loaded_file(data->package, file);
 365         msi_free(file);
 366
 367         if (!f)
 368         {
 369             WARN("unknown file in cabinet (%s)\n",debugstr_a(pfdin->psz1));
 370             return 0;
 371         }
 372
 373         if (f->state != msifs_missing && f->state != msifs_overwrite)
 374         {
 375             TRACE("Skipping extraction of %s\n",debugstr_a(pfdin->psz1));
 376             return 0;
 377         }
 378
 379         msi_file_update_ui( data->package, f, szInstallFiles );
 380
 381         TRACE("extracting %s\n", debugstr_w(f->TargetPath) );
 382
 383         attrs = f->Attributes & (FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM);
 384         if (!attrs) attrs = FILE_ATTRIBUTE_NORMAL;
 385
 386         handle = CreateFileW( f->TargetPath, GENERIC_READ | GENERIC_WRITE, 0,
 387                               NULL, CREATE_ALWAYS, attrs, NULL );
 388         if ( handle == INVALID_HANDLE_VALUE )
 389         {
 390             if ( GetFileAttributesW( f->TargetPath ) != INVALID_FILE_ATTRIBUTES )
 391                 f->state = msifs_installed;
 392             else
 393                 ERR("failed to create %s (error %d)\n",
 394                     debugstr_w( f->TargetPath ), GetLastError() );
 395
 396             return 0;
 397         }
 398
 399         f->state = msifs_installed;
 400         return (INT_PTR) handle;
 401     }
 402     case fdintCLOSE_FILE_INFO:
 403     {
 404         CabData *data = (CabData*) pfdin->pv;
 405         FILETIME ft;
 406         FILETIME ftLocal;
 407         HANDLE handle = (HANDLE) pfdin->hf;
 408
 409         data->mi->is_continuous = FALSE;
 410
 411         if (!DosDateTimeToFileTime(pfdin->date, pfdin->time, &ft))
 412             return -1;
 413         if (!LocalFileTimeToFileTime(&ft, &ftLocal))
 414             return -1;
 415         if (!SetFileTime(handle, &ftLocal, 0, &ftLocal))
 416             return -1;
 417         CloseHandle(handle);
 418         return 1;
 419     }
 420     default:
 421         return 0;
 422     }
 423 }
 424
 425 /***********************************************************************
 426  *            extract_cabinet_file
 427  *
 428  * Extract files from a cab file.
 429  */
 430 static BOOL extract_cabinet_file(MSIPACKAGE* package, struct media_info *mi)
 431 {
 432     LPSTR cabinet, cab_path = NULL;
 433     LPWSTR ptr;
 434     HFDI hfdi;
 435     ERF erf;
 436     BOOL ret = FALSE;
 437     CabData data;
 438
 439     TRACE("Extracting %s\n", debugstr_w(mi->source));
 440
 441     hfdi = FDICreate(cabinet_alloc, cabinet_free, cabinet_open, cabinet_read,
 442                      cabinet_write, cabinet_close, cabinet_seek, 0, &erf);
 443     if (!hfdi)
 444     {
 445         ERR("FDICreate failed\n");
 446         return FALSE;
 447     }
 448
 449     ptr = strrchrW(mi->source, '\\') + 1;
 450     cabinet = strdupWtoA(ptr);
 451     if (!cabinet)
 452         goto done;
 453
 454     cab_path = strdupWtoA(mi->source);
 455     if (!cab_path)
 456         goto done;
 457
 458     cab_path[ptr - mi->source] = '\0';
 459
 460     data.package = package;
 461     data.mi = mi;
 462
 463     ret = FDICopy(hfdi, cabinet, cab_path, 0, cabinet_notify, NULL, &data);
 464     if (!ret)
 465         ERR("FDICopy failed\n");
 466
 467 done:
 468     FDIDestroy(hfdi);
 469     msi_free(cabinet);
 470     msi_free(cab_path);
 471
 472     if (ret)
 473         mi->is_extracted = TRUE;
 474
 475     return ret;
 476 }
 477
 478 static VOID set_file_source(MSIPACKAGE* package, MSIFILE* file, LPCWSTR path)
 479 {
 480     if (!file->IsCompressed)
 481     {
 482         LPWSTR p, path;
 483         p = resolve_folder(package, file->Component->Directory, TRUE, FALSE, TRUE, NULL);
 484         path = build_directory_name(2, p, file->ShortName);
 485         if (file->LongName &&
 486             INVALID_FILE_ATTRIBUTES == GetFileAttributesW( path ))
 487         {
 488             msi_free(path);
 489             path = build_directory_name(2, p, file->LongName);
 490         }
 491         file->SourcePath = path;
 492         msi_free(p);
 493     }
 494     else
 495         file->SourcePath = build_directory_name(2, path, file->File);
 496 }
 497
 498 static void free_media_info( struct media_info *mi )
 499 {
 500     msi_free( mi->disk_prompt );
 501     msi_free( mi->cabinet );
 502     msi_free( mi->volume_label );
 503     msi_free( mi->first_volume );
 504     msi_free( mi );
 505 }
 506
 507 static UINT load_media_info(MSIPACKAGE *package, MSIFILE *file, struct media_info *mi)
 508 {
 509     MSIRECORD *row;
 510     LPWSTR source_dir;
 511     LPWSTR source;
 512     DWORD options;
 513     UINT r;
 514
 515     static const WCHAR query[] = {
 516         'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
 517         '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
 518         '`','L','a','s','t','S','e','q','u','e','n','c','e','`',' ','>','=',
 519         ' ','%','i',' ','A','N','D',' ','`','D','i','s','k','I','d','`',' ','>','=',
 520         ' ','%','i',' ','O','R','D','E','R',' ','B','Y',' ',
 521         '`','D','i','s','k','I','d','`',0
 522     };
 523
 524     row = MSI_QueryGetRecord(package->db, query, file->Sequence, mi->disk_id);
 525     if (!row)
 526     {
 527         TRACE("Unable to query row\n");
 528         return ERROR_FUNCTION_FAILED;
 529     }
 530
 531     mi->is_extracted = FALSE;
 532     mi->disk_id = MSI_RecordGetInteger(row, 1);
 533     mi->last_sequence = MSI_RecordGetInteger(row, 2);
 534     msi_free(mi->disk_prompt);
 535     mi->disk_prompt = strdupW(MSI_RecordGetString(row, 3));
 536     msi_free(mi->cabinet);
 537     mi->cabinet = strdupW(MSI_RecordGetString(row, 4));
 538     msi_free(mi->volume_label);
 539     mi->volume_label = strdupW(MSI_RecordGetString(row, 5));
 540     msiobj_release(&row->hdr);
 541
 542     if (!mi->first_volume)
 543         mi->first_volume = strdupW(mi->volume_label);
 544
 545     source_dir = msi_dup_property(package, cszSourceDir);
 546     lstrcpyW(mi->source, source_dir);
 547
 548     PathStripToRootW(source_dir);
 549     mi->type = GetDriveTypeW(source_dir);
 550
 551     if (file->IsCompressed && mi->cabinet)
 552     {
 553         if (mi->cabinet[0] == '#')
 554         {
 555             r = writeout_cabinet_stream(package, &mi->cabinet[1], mi->source);
 556             if (r != ERROR_SUCCESS)
 557             {
 558                 ERR("Failed to extract cabinet stream\n");
 559                 return ERROR_FUNCTION_FAILED;
 560             }
 561         }
 562         else
 563             lstrcatW(mi->source, mi->cabinet);
 564     }
 565
 566     options = MSICODE_PRODUCT;
 567     if (mi->type == DRIVE_CDROM || mi->type == DRIVE_REMOVABLE)
 568     {
 569         source = source_dir;
 570         options |= MSISOURCETYPE_MEDIA;
 571     }
 572     else if (package->BaseURL && UrlIsW(package->BaseURL, URLIS_URL))
 573     {
 574         source = package->BaseURL;
 575         options |= MSISOURCETYPE_URL;
 576     }
 577     else
 578     {
 579         source = mi->source;
 580         options |= MSISOURCETYPE_NETWORK;
 581     }
 582
 583     if (mi->type == DRIVE_CDROM || mi->type == DRIVE_REMOVABLE)
 584         msi_package_add_media_disk(package, MSIINSTALLCONTEXT_USERUNMANAGED,
 585                                    MSICODE_PRODUCT, mi->disk_id,
 586                                    mi->volume_label, mi->disk_prompt);
 587
 588     msi_package_add_info(package, MSIINSTALLCONTEXT_USERUNMANAGED,
 589                          options, INSTALLPROPERTY_LASTUSEDSOURCEW, source);
 590
 591     msi_free(source_dir);
 592     return ERROR_SUCCESS;
 593 }
 594
 595 /* FIXME: search NETWORK and URL sources as well */
 596 static UINT find_published_source(MSIPACKAGE *package, struct media_info *mi)
 597 {
 598     WCHAR source[MAX_PATH];
 599     WCHAR volume[MAX_PATH];
 600     WCHAR prompt[MAX_PATH];
 601     DWORD volumesz, promptsz;
 602     DWORD index, size;
 603     WORD id;
 604     UINT r;
 605
 606     r = MsiSourceListGetInfoW(package->ProductCode, NULL,
 607                               MSIINSTALLCONTEXT_USERUNMANAGED, MSICODE_PRODUCT,
 608                               INSTALLPROPERTY_LASTUSEDSOURCEW, source, &size);
 609     if (r != ERROR_SUCCESS)
 610         return r;
 611
 612     index = 0;
 613     volumesz = MAX_PATH;
 614     promptsz = MAX_PATH;
 615     while (MsiSourceListEnumMediaDisksW(package->ProductCode, NULL,
 616                                         MSIINSTALLCONTEXT_USERUNMANAGED,
 617                                         MSICODE_PRODUCT, index++, &id,
 618                                         volume, &volumesz, prompt, &promptsz) == ERROR_SUCCESS)
 619     {
 620         mi->disk_id = id;
 621         mi->volume_label = msi_realloc(mi->volume_label, ++volumesz * sizeof(WCHAR));
 622         lstrcpyW(mi->volume_label, volume);
 623         mi->disk_prompt = msi_realloc(mi->disk_prompt, ++promptsz * sizeof(WCHAR));
 624         lstrcpyW(mi->disk_prompt, prompt);
 625
 626         if (source_matches_volume(mi, source))
 627         {
 628             /* FIXME: what about SourceDir */
 629             lstrcpyW(mi->source, source);
 630             lstrcatW(mi->source, mi->cabinet);
 631             return ERROR_SUCCESS;
 632         }
 633     }
 634
 635     return ERROR_FUNCTION_FAILED;
 636 }
 637
 638 static UINT ready_media(MSIPACKAGE *package, MSIFILE *file, struct media_info *mi)
 639 {
 640     UINT rc = ERROR_SUCCESS;
 641
 642     /* media info for continuous cabinet is already loaded */
 643     if (mi->is_continuous)
 644         return ERROR_SUCCESS;
 645
 646     rc = load_media_info(package, file, mi);
 647     if (rc != ERROR_SUCCESS)
 648     {
 649         ERR("Unable to load media info\n");
 650         return ERROR_FUNCTION_FAILED;
 651     }
 652
 653     /* cabinet is internal, no checks needed */
 654     if (!mi->cabinet || mi->cabinet[0] == '#')
 655         return ERROR_SUCCESS;
 656
 657     /* package should be downloaded */
 658     if (file->IsCompressed &&
 659         GetFileAttributesW(mi->source) == INVALID_FILE_ATTRIBUTES &&
 660         package->BaseURL && UrlIsW(package->BaseURL, URLIS_URL))
 661     {
 662         WCHAR temppath[MAX_PATH];
 663
 664         msi_download_file(mi->source, temppath);
 665         lstrcpyW(mi->source, temppath);
 666         return ERROR_SUCCESS;
 667     }
 668
 669     /* check volume matches, change media if not */
 670     if (mi->volume_label && mi->disk_id > 1 &&
 671         lstrcmpW(mi->first_volume, mi->volume_label))
 672     {
 673         LPWSTR source = msi_dup_property(package, cszSourceDir);
 674         BOOL matches;
 675
 676         matches = source_matches_volume(mi, source);
 677         msi_free(source);
 678
 679         if ((mi->type == DRIVE_CDROM || mi->type == DRIVE_REMOVABLE) && !matches)
 680         {
 681             rc = msi_change_media(package, mi);
 682             if (rc != ERROR_SUCCESS)
 683                 return rc;
 684         }
 685     }
 686
 687     if (file->IsCompressed &&
 688         GetFileAttributesW(mi->source) == INVALID_FILE_ATTRIBUTES)
 689     {
 690         /* FIXME: this might be done earlier in the install process */
 691         rc = find_published_source(package, mi);
 692         if (rc != ERROR_SUCCESS)
 693         {
 694             ERR("Cabinet not found: %s\n", debugstr_w(mi->source));
 695             return ERROR_INSTALL_FAILURE;
 696         }
 697     }
 698
 699     return ERROR_SUCCESS;
 700 }
 701
 702 static UINT get_file_target(MSIPACKAGE *package, LPCWSTR file_key,
 703                             MSIFILE** file)
 704 {
 705     LIST_FOR_EACH_ENTRY( *file, &package->files, MSIFILE, entry )
 706     {
 707         if (lstrcmpW( file_key, (*file)->File )==0)
 708         {
 709             if ((*file)->state >= msifs_overwrite)
 710                 return ERROR_SUCCESS;
 711             else
 712                 return ERROR_FILE_NOT_FOUND;
 713         }
 714     }
 715
 716     return ERROR_FUNCTION_FAILED;
 717 }
 718
 719 static void schedule_install_files(MSIPACKAGE *package)
 720 {
 721     MSIFILE *file;
 722
 723     LIST_FOR_EACH_ENTRY(file, &package->files, MSIFILE, entry)
 724     {
 725         if (!ACTION_VerifyComponentForAction(file->Component, INSTALLSTATE_LOCAL))
 726         {
 727             TRACE("File %s is not scheduled for install\n", debugstr_w(file->File));
 728
 729             ui_progress(package,2,file->FileSize,0,0);
 730             file->state = msifs_skipped;
 731         }
 732     }
 733 }
 734
 735 static UINT copy_file(MSIFILE *file)
 736 {
 737     BOOL ret;
 738
 739     ret = CopyFileW(file->SourcePath, file->TargetPath, FALSE);
 740     if (ret)
 741     {
 742         file->state = msifs_installed;
 743         return ERROR_SUCCESS;
 744     }
 745
 746     return GetLastError();
 747 }
 748
 749 static UINT copy_install_file(MSIFILE *file)
 750 {
 751     UINT gle;
 752
 753     TRACE("Copying %s to %s\n", debugstr_w(file->SourcePath),
 754           debugstr_w(file->TargetPath));
 755
 756     gle = copy_file(file);
 757     if (gle == ERROR_SUCCESS)
 758         return gle;
 759
 760     if (gle == ERROR_ALREADY_EXISTS && file->state == msifs_overwrite)
 761     {
 762         TRACE("overwriting existing file\n");
 763         gle = ERROR_SUCCESS;
 764     }
 765     else if (gle == ERROR_FILE_NOT_FOUND)
 766     {
 767         /* FIXME: this needs to be tested, I'm pretty sure it fails */
 768         TRACE("Source file not found\n");
 769         gle = ERROR_SUCCESS;
 770     }
 771     else if (gle == ERROR_ACCESS_DENIED)
 772     {
 773         SetFileAttributesW(file->TargetPath, FILE_ATTRIBUTE_NORMAL);
 774
 775         gle = copy_file(file);
 776         TRACE("Overwriting existing file: %d\n", gle);
 777     }
 778     else if (!(file->Attributes & msidbFileAttributesVital))
 779     {
 780         TRACE("Ignoring error for nonvital\n");
 781         gle = ERROR_SUCCESS;
 782     }
 783
 784     return gle;
 785 }
 786
 787 static BOOL check_dest_hash_matches(MSIFILE *file)
 788 {
 789     MSIFILEHASHINFO hash;
 790     UINT r;
 791
 792     if (!file->hash.dwFileHashInfoSize)
 793         return FALSE;
 794
 795     hash.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
 796     r = MsiGetFileHashW(file->TargetPath, 0, &hash);
 797     if (r != ERROR_SUCCESS)
 798         return FALSE;
 799
 800     return !memcmp(&hash, &file->hash, sizeof(MSIFILEHASHINFO));
 801 }
 802
 803 /*
 804  * ACTION_InstallFiles()
 805  *
 806  * For efficiency, this is done in two passes:
 807  * 1) Correct all the TargetPaths and determine what files are to be installed.
 808  * 2) Extract Cabinets and copy files.
 809  */
 810 UINT ACTION_InstallFiles(MSIPACKAGE *package)
 811 {
 812     struct media_info *mi;
 813     UINT rc = ERROR_SUCCESS;
 814     MSIFILE *file;
 815
 816     /* increment progress bar each time action data is sent */
 817     ui_progress(package,1,1,0,0);
 818
 819     schedule_install_files(package);
 820
 821     /*
 822      * Despite MSDN specifying that the CreateFolders action
 823      * should be called before InstallFiles, some installers don't
 824      * do that, and they seem to work correctly.  We need to create
 825      * directories here to make sure that the files can be copied.
 826      */
 827     msi_create_component_directories( package );
 828
 829     mi = msi_alloc_zero( sizeof(struct media_info) );
 830
 831     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
 832     {
 833         if (file->state != msifs_missing && !mi->is_continuous && file->state != msifs_overwrite)
 834             continue;
 835
 836         if (check_dest_hash_matches(file))
 837         {
 838             TRACE("File hashes match, not overwriting\n");
 839             continue;
 840         }
 841
 842         if (file->Sequence > mi->last_sequence || mi->is_continuous ||
 843             (file->IsCompressed && !mi->is_extracted))
 844         {
 845             rc = ready_media(package, file, mi);
 846             if (rc != ERROR_SUCCESS)
 847             {
 848                 ERR("Failed to ready media\n");
 849                 break;
 850             }
 851
 852             if (file->IsCompressed && !extract_cabinet_file(package, mi))
 853             {
 854                 ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
 855                 rc = ERROR_FUNCTION_FAILED;
 856                 break;
 857             }
 858         }
 859
 860         set_file_source(package, file, mi->source);
 861
 862         TRACE("file paths %s to %s\n",debugstr_w(file->SourcePath),
 863               debugstr_w(file->TargetPath));
 864
 865         if (!file->IsCompressed)
 866         {
 867             msi_file_update_ui(package, file, szInstallFiles);
 868             rc = copy_install_file(file);
 869             if (rc != ERROR_SUCCESS)
 870             {
 871                 ERR("Failed to copy %s to %s (%d)\n", debugstr_w(file->SourcePath),
 872                     debugstr_w(file->TargetPath), rc);
 873                 rc = ERROR_INSTALL_FAILURE;
 874                 break;
 875             }
 876         }
 877         else if (file->state != msifs_installed)
 878         {
 879             ERR("compressed file wasn't extracted (%s)\n", debugstr_w(file->TargetPath));
 880             rc = ERROR_INSTALL_FAILURE;
 881             break;
 882         }
 883     }
 884
 885     free_media_info( mi );
 886     return rc;
 887 }
 888
 889 static UINT ITERATE_DuplicateFiles(MSIRECORD *row, LPVOID param)
 890 {
 891     MSIPACKAGE *package = (MSIPACKAGE*)param;
 892     WCHAR dest_name[0x100];
 893     LPWSTR dest_path, dest;
 894     LPCWSTR file_key, component;
 895     DWORD sz;
 896     DWORD rc;
 897     MSICOMPONENT *comp;
 898     MSIFILE *file;
 899
 900     component = MSI_RecordGetString(row,2);
 901     comp = get_loaded_component(package,component);
 902
 903     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ))
 904     {
 905         TRACE("Skipping copy due to disabled component %s\n",
 906                         debugstr_w(component));
 907
 908         /* the action taken was the same as the current install state */
 909         comp->Action = comp->Installed;
 910
 911         return ERROR_SUCCESS;
 912     }
 913
 914     comp->Action = INSTALLSTATE_LOCAL;
 915
 916     file_key = MSI_RecordGetString(row,3);
 917     if (!file_key)
 918     {
 919         ERR("Unable to get file key\n");
 920         return ERROR_FUNCTION_FAILED;
 921     }
 922
 923     rc = get_file_target(package,file_key,&file);
 924
 925     if (rc != ERROR_SUCCESS)
 926     {
 927         ERR("Original file unknown %s\n",debugstr_w(file_key));
 928         return ERROR_SUCCESS;
 929     }
 930
 931     if (MSI_RecordIsNull(row,4))
 932         strcpyW(dest_name,strrchrW(file->TargetPath,'\\')+1);
 933     else
 934     {
 935         sz=0x100;
 936         MSI_RecordGetStringW(row,4,dest_name,&sz);
 937         reduce_to_longfilename(dest_name);
 938     }
 939
 940     if (MSI_RecordIsNull(row,5))
 941     {
 942         LPWSTR p;
 943         dest_path = strdupW(file->TargetPath);
 944         p = strrchrW(dest_path,'\\');
 945         if (p)
 946             *p=0;
 947     }
 948     else
 949     {
 950         LPCWSTR destkey;
 951         destkey = MSI_RecordGetString(row,5);
 952         dest_path = resolve_folder(package, destkey, FALSE, FALSE, TRUE, NULL);
 953         if (!dest_path)
 954         {
 955             /* try a Property */
 956             dest_path = msi_dup_property( package, destkey );
 957             if (!dest_path)
 958             {
 959                 FIXME("Unable to get destination folder, try AppSearch properties\n");
 960                 return ERROR_SUCCESS;
 961             }
 962         }
 963     }
 964
 965     dest = build_directory_name(2, dest_path, dest_name);
 966     create_full_pathW(dest_path);
 967
 968     TRACE("Duplicating file %s to %s\n",debugstr_w(file->TargetPath),
 969                     debugstr_w(dest));
 970
 971     if (strcmpW(file->TargetPath,dest))
 972         rc = !CopyFileW(file->TargetPath,dest,TRUE);
 973     else
 974         rc = ERROR_SUCCESS;
 975
 976     if (rc != ERROR_SUCCESS)
 977         ERR("Failed to copy file %s -> %s, last error %d\n",
 978             debugstr_w(file->TargetPath), debugstr_w(dest_path), GetLastError());
 979
 980     FIXME("We should track these duplicate files as well\n");
 981
 982     msi_free(dest_path);
 983     msi_free(dest);
 984
 985     msi_file_update_ui(package, file, szDuplicateFiles);
 986
 987     return ERROR_SUCCESS;
 988 }
 989
 990 UINT ACTION_DuplicateFiles(MSIPACKAGE *package)
 991 {
 992     UINT rc;
 993     MSIQUERY * view;
 994     static const WCHAR ExecSeqQuery[] =
 995         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
 996          '`','D','u','p','l','i','c','a','t','e','F','i','l','e','`',0};
 997
 998     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
 999     if (rc != ERROR_SUCCESS)
1000         return ERROR_SUCCESS;
1001
1002     rc = MSI_IterateRecords(view, NULL, ITERATE_DuplicateFiles, package);
1003     msiobj_release(&view->hdr);
1004
1005     return rc;
1006 }
1007
1008 /* compares the version of a file read from the filesystem and
1009  * the version specified in the File table
1010  */
1011 static int msi_compare_file_version( MSIFILE *file )
1012 {
1013     WCHAR version[MAX_PATH];
1014     DWORD size;
1015     UINT r;
1016
1017     size = MAX_PATH;
1018     version[0] = '\0';
1019     r = MsiGetFileVersionW( file->TargetPath, version, &size, NULL, NULL );
1020     if ( r != ERROR_SUCCESS )
1021         return 0;
1022
1023     return lstrcmpW( version, file->Version );
1024 }
1025
1026 UINT ACTION_RemoveFiles( MSIPACKAGE *package )
1027 {
1028     MSIFILE *file;
1029
1030     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
1031     {
1032         MSIRECORD *uirow;
1033         LPWSTR uipath, p;
1034
1035         if ( !file->Component )
1036             continue;
1037         if ( file->Component->Installed == INSTALLSTATE_LOCAL )
1038             continue;
1039
1040         if ( file->state == msifs_installed )
1041             ERR("removing installed file %s\n", debugstr_w(file->TargetPath));
1042
1043         if ( file->state != msifs_present )
1044             continue;
1045
1046         /* only remove a file if the version to be installed
1047          * is strictly newer than the old file
1048          */
1049         if ( msi_compare_file_version( file ) >= 0 )
1050             continue;
1051
1052         TRACE("removing %s\n", debugstr_w(file->File) );
1053         if ( !DeleteFileW( file->TargetPath ) )
1054             ERR("failed to delete %s\n",  debugstr_w(file->TargetPath) );
1055         file->state = msifs_missing;
1056
1057         /* the UI chunk */
1058         uirow = MSI_CreateRecord( 9 );
1059         MSI_RecordSetStringW( uirow, 1, file->FileName );
1060         uipath = strdupW( file->TargetPath );
1061         p = strrchrW(uipath,'\\');
1062         if (p)
1063             p[1]=0;
1064         MSI_RecordSetStringW( uirow, 9, uipath);
1065         ui_actiondata( package, szRemoveFiles, uirow);
1066         msiobj_release( &uirow->hdr );
1067         msi_free( uipath );
1068         /* FIXME: call ui_progress here? */
1069     }
1070
1071     return ERROR_SUCCESS;
1072 }