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