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