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