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