comctl32/tests: Write-strings warnings fix.
[wine] / 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 "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, const WCHAR *action )
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, action, 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         DWORD attrs;
214
215         file = strdupAtoW(pfdin->psz1);
216         f = get_loaded_file(data->package, file);
217         msi_free(file);
218
219         if (!f)
220         {
221             WARN("unknown file in cabinet (%s)\n",debugstr_a(pfdin->psz1));
222             return 0;
223         }
224
225         if (f->state != msifs_missing && f->state != msifs_overwrite)
226         {
227             TRACE("Skipping extraction of %s\n",debugstr_a(pfdin->psz1));
228             return 0;
229         }
230
231         msi_file_update_ui( data->package, f, szInstallFiles );
232
233         TRACE("extracting %s\n", debugstr_w(f->TargetPath) );
234
235         attrs = f->Attributes & (FILE_ATTRIBUTE_READONLY|FILE_ATTRIBUTE_HIDDEN|FILE_ATTRIBUTE_SYSTEM);
236         if (!attrs) attrs = FILE_ATTRIBUTE_NORMAL;
237
238         handle = CreateFileW( f->TargetPath, GENERIC_READ | GENERIC_WRITE, 0,
239                               NULL, CREATE_ALWAYS, attrs, NULL );
240         if ( handle == INVALID_HANDLE_VALUE )
241         {
242             ERR("failed to create %s (error %ld)\n",
243                 debugstr_w( f->TargetPath ), GetLastError() );
244             return 0;
245         }
246
247         f->state = msifs_installed;
248         return (INT_PTR) handle;
249     }
250     case fdintCLOSE_FILE_INFO:
251     {
252         FILETIME ft;
253         FILETIME ftLocal;
254         HANDLE handle = (HANDLE) pfdin->hf;
255
256         if (!DosDateTimeToFileTime(pfdin->date, pfdin->time, &ft))
257             return -1;
258         if (!LocalFileTimeToFileTime(&ft, &ftLocal))
259             return -1;
260         if (!SetFileTime(handle, &ftLocal, 0, &ftLocal))
261             return -1;
262         CloseHandle(handle);
263         return 1;
264     }
265     default:
266         return 0;
267     }
268 }
269
270 /***********************************************************************
271  *            extract_cabinet_file
272  *
273  * Extract files from a cab file.
274  */
275 static BOOL extract_cabinet_file(MSIPACKAGE* package, LPCWSTR source, 
276                                  LPCWSTR path)
277 {
278     HFDI hfdi;
279     ERF erf;
280     BOOL ret;
281     char *cabinet;
282     char *cab_path;
283     CabData data;
284
285     TRACE("Extracting %s to %s\n",debugstr_w(source), debugstr_w(path));
286
287     hfdi = FDICreate(cabinet_alloc,
288                      cabinet_free,
289                      cabinet_open,
290                      cabinet_read,
291                      cabinet_write,
292                      cabinet_close,
293                      cabinet_seek,
294                      0,
295                      &erf);
296     if (!hfdi)
297     {
298         ERR("FDICreate failed\n");
299         return FALSE;
300     }
301
302     if (!(cabinet = strdupWtoA( source )))
303     {
304         FDIDestroy(hfdi);
305         return FALSE;
306     }
307     if (!(cab_path = strdupWtoA( path )))
308     {
309         FDIDestroy(hfdi);
310         msi_free(cabinet);
311         return FALSE;
312     }
313
314     data.package = package;
315     data.cab_path = cab_path;
316
317     ret = FDICopy(hfdi, cabinet, "", 0, cabinet_notify, NULL, &data);
318
319     if (!ret)
320         ERR("FDICopy failed\n");
321
322     FDIDestroy(hfdi);
323
324     msi_free(cabinet);
325     msi_free(cab_path);
326
327     return ret;
328 }
329
330 static VOID set_file_source(MSIPACKAGE* package, MSIFILE* file, MSICOMPONENT*
331         comp, LPCWSTR path)
332 {
333     if (file->Attributes & msidbFileAttributesNoncompressed)
334     {
335         LPWSTR p, path;
336         p = resolve_folder(package, comp->Directory, TRUE, FALSE, NULL);
337         path = build_directory_name(2, p, file->ShortName);
338         if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW( path ))
339         {
340             msi_free(path);
341             path = build_directory_name(2, p, file->LongName);
342         }
343         file->SourcePath = path;
344         msi_free(p);
345     }
346     else
347         file->SourcePath = build_directory_name(2, path, file->File);
348 }
349
350 struct media_info {
351     UINT last_sequence; 
352     LPWSTR last_volume;
353     LPWSTR last_path;
354     DWORD count;
355     WCHAR source[MAX_PATH];
356 };
357
358 static struct media_info *create_media_info( void )
359 {
360     struct media_info *mi;
361
362     mi = msi_alloc( sizeof *mi  );
363     if (mi)
364     {
365         mi->last_sequence = 0; 
366         mi->last_volume = NULL;
367         mi->last_path = NULL;
368         mi->count = 0;
369         mi->source[0] = 0;
370     }
371
372     return mi;
373 }
374
375 static void free_media_info( struct media_info *mi )
376 {
377     msi_free( mi->last_path );
378     msi_free( mi );
379 }
380
381 static UINT ready_media_for_file( MSIPACKAGE *package, struct media_info *mi,
382                                   MSIFILE *file )
383 {
384     UINT rc = ERROR_SUCCESS;
385     MSIRECORD * row = 0;
386     static const WCHAR ExecSeqQuery[] =
387         {'S','E','L','E','C','T',' ','*',' ', 'F','R','O','M',' ',
388          '`','M','e','d','i','a','`',' ','W','H','E','R','E',' ',
389          '`','L','a','s','t','S','e','q','u','e','n','c','e','`',' ','>','=',
390          ' ','%', 'i',' ','O','R','D','E','R',' ','B','Y',' ',
391          '`','L','a','s','t','S','e','q','u','e','n','c','e','`',0};
392     LPCWSTR cab, volume;
393     DWORD sz;
394     INT seq;
395     LPCWSTR prompt;
396     MSICOMPONENT *comp = file->Component;
397
398     if (file->Sequence <= mi->last_sequence)
399     {
400         set_file_source(package,file,comp,mi->last_path);
401         TRACE("Media already ready (%u, %u)\n",file->Sequence,mi->last_sequence);
402         return ERROR_SUCCESS;
403     }
404
405     mi->count ++;
406     row = MSI_QueryGetRecord(package->db, ExecSeqQuery, file->Sequence);
407     if (!row)
408     {
409         TRACE("Unable to query row\n");
410         return ERROR_FUNCTION_FAILED;
411     }
412
413     seq = MSI_RecordGetInteger(row,2);
414     mi->last_sequence = seq;
415
416     volume = MSI_RecordGetString(row, 5);
417     prompt = MSI_RecordGetString(row, 3);
418
419     msi_free(mi->last_path);
420     mi->last_path = NULL;
421
422     if (file->Attributes & msidbFileAttributesNoncompressed)
423     {
424         mi->last_path = resolve_folder(package, comp->Directory, TRUE, FALSE, NULL);
425         set_file_source(package,file,comp,mi->last_path);
426
427         MsiSourceListAddMediaDiskW(package->ProductCode, NULL, 
428             MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT, mi->count, volume,
429             prompt);
430
431         MsiSourceListSetInfoW(package->ProductCode, NULL, 
432                 MSIINSTALLCONTEXT_USERMANAGED, 
433                 MSICODE_PRODUCT|MSISOURCETYPE_MEDIA,
434                 INSTALLPROPERTY_LASTUSEDSOURCEW, mi->last_path);
435         msiobj_release(&row->hdr);
436         return rc;
437     }
438
439     cab = MSI_RecordGetString(row,4);
440     if (cab)
441     {
442         TRACE("Source is CAB %s\n",debugstr_w(cab));
443         /* the stream does not contain the # character */
444         if (cab[0]=='#')
445         {
446             LPWSTR path;
447
448             writeout_cabinet_stream(package,&cab[1],mi->source);
449             mi->last_path = strdupW(mi->source);
450             *(strrchrW(mi->last_path,'\\')+1)=0;
451
452             path = msi_dup_property( package, cszSourceDir );
453
454             MsiSourceListAddMediaDiskW(package->ProductCode, NULL, 
455                 MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT, mi->count,
456                 volume, prompt);
457
458             MsiSourceListSetInfoW(package->ProductCode, NULL,
459                 MSIINSTALLCONTEXT_USERMANAGED,
460                 MSICODE_PRODUCT|MSISOURCETYPE_NETWORK,
461                 INSTALLPROPERTY_LASTUSEDSOURCEW, path);
462
463             msi_free(path);
464         }
465         else
466         {
467             sz = MAX_PATH;
468             mi->last_path = msi_alloc(MAX_PATH*sizeof(WCHAR));
469             if (MSI_GetPropertyW(package, cszSourceDir, mi->source, &sz))
470             {
471                 ERR("No Source dir defined\n");
472                 rc = ERROR_FUNCTION_FAILED;
473             }
474             else
475             {
476                 strcpyW(mi->last_path,mi->source);
477                 strcatW(mi->source,cab);
478
479                 MsiSourceListSetInfoW(package->ProductCode, NULL,
480                             MSIINSTALLCONTEXT_USERMANAGED,
481                             MSICODE_PRODUCT|MSISOURCETYPE_MEDIA,
482                             INSTALLPROPERTY_LASTUSEDSOURCEW, mi->last_path);
483
484                 /* extract the cab file into a folder in the temp folder */
485                 sz = MAX_PATH;
486                 if (MSI_GetPropertyW(package, cszTempFolder,mi->last_path, &sz) 
487                                     != ERROR_SUCCESS)
488                     GetTempPathW(MAX_PATH,mi->last_path);
489             }
490         }
491         rc = !extract_cabinet_file(package, mi->source, mi->last_path);
492     }
493     else
494     {
495         sz = MAX_PATH;
496         mi->last_path = msi_alloc(MAX_PATH*sizeof(WCHAR));
497         MSI_GetPropertyW(package,cszSourceDir,mi->source,&sz);
498         strcpyW(mi->last_path,mi->source);
499
500         MsiSourceListSetInfoW(package->ProductCode, NULL,
501                     MSIINSTALLCONTEXT_USERMANAGED,
502                     MSICODE_PRODUCT|MSISOURCETYPE_MEDIA,
503                     INSTALLPROPERTY_LASTUSEDSOURCEW, mi->last_path);
504     }
505     set_file_source(package, file, comp, mi->last_path);
506
507     MsiSourceListAddMediaDiskW(package->ProductCode, NULL,
508             MSIINSTALLCONTEXT_USERMANAGED, MSICODE_PRODUCT, mi->count, volume,
509             prompt);
510
511     msiobj_release(&row->hdr);
512
513     return rc;
514 }
515
516 static UINT get_file_target(MSIPACKAGE *package, LPCWSTR file_key, 
517                             MSIFILE** file)
518 {
519     LIST_FOR_EACH_ENTRY( *file, &package->files, MSIFILE, entry )
520     {
521         if (lstrcmpW( file_key, (*file)->File )==0)
522         {
523             if ((*file)->state >= msifs_overwrite)
524                 return ERROR_SUCCESS;
525             else
526                 return ERROR_FILE_NOT_FOUND;
527         }
528     }
529
530     return ERROR_FUNCTION_FAILED;
531 }
532
533 /*
534  * ACTION_InstallFiles()
535  * 
536  * For efficiency, this is done in two passes:
537  * 1) Correct all the TargetPaths and determine what files are to be installed.
538  * 2) Extract Cabinets and copy files.
539  */
540 UINT ACTION_InstallFiles(MSIPACKAGE *package)
541 {
542     struct media_info *mi;
543     UINT rc = ERROR_SUCCESS;
544     LPWSTR ptr;
545     MSIFILE *file;
546
547     /* increment progress bar each time action data is sent */
548     ui_progress(package,1,1,0,0);
549
550     /* handle the keys for the SourceList */
551     ptr = strrchrW(package->PackagePath,'\\');
552     if (ptr)
553     {
554         ptr ++;
555         MsiSourceListSetInfoW(package->ProductCode, NULL,
556                 MSIINSTALLCONTEXT_USERMANAGED,
557                 MSICODE_PRODUCT,
558                 INSTALLPROPERTY_PACKAGENAMEW, ptr);
559     }
560     /* FIXME("Write DiskPrompt\n"); */
561     
562     /* Pass 1 */
563     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
564     {
565         if (!ACTION_VerifyComponentForAction( file->Component, INSTALLSTATE_LOCAL ))
566         {
567             ui_progress(package,2,file->FileSize,0,0);
568             TRACE("File %s is not scheduled for install\n",
569                    debugstr_w(file->File));
570
571             file->state = msifs_skipped;
572         }
573     }
574
575     /*
576      * Despite MSDN specifying that the CreateFolders action
577      * should be called before InstallFiles, some installers don't
578      * do that, and they seem to work correctly.  We need to create
579      * directories here to make sure that the files can be copied.
580      */
581     msi_create_component_directories( package );
582
583     mi = create_media_info();
584
585     /* Pass 2 */
586     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
587     {
588         if (file->state != msifs_missing && file->state != msifs_overwrite)
589             continue;
590
591         TRACE("Pass 2: %s\n",debugstr_w(file->File));
592
593         rc = ready_media_for_file( package, mi, file );
594         if (rc != ERROR_SUCCESS)
595         {
596             ERR("Unable to ready media\n");
597             rc = ERROR_FUNCTION_FAILED;
598             break;
599         }
600
601         TRACE("file paths %s to %s\n",debugstr_w(file->SourcePath),
602               debugstr_w(file->TargetPath));
603
604         if (file->state != msifs_missing && file->state != msifs_overwrite)
605             continue;
606
607         /* compressed files are extracted in ready_media_for_file */
608         if (~file->Attributes & msidbFileAttributesNoncompressed)
609         {
610             if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(file->TargetPath))
611                 ERR("compressed file wasn't extracted (%s)\n",
612                     debugstr_w(file->TargetPath));
613             continue;
614         }
615
616         rc = CopyFileW(file->SourcePath,file->TargetPath,FALSE);
617         if (!rc)
618         {
619             rc = GetLastError();
620             ERR("Unable to copy file (%s -> %s) (error %d)\n",
621                 debugstr_w(file->SourcePath), debugstr_w(file->TargetPath), rc);
622             if (rc == ERROR_ALREADY_EXISTS && file->state == msifs_overwrite)
623             {
624                 rc = 0;
625             }
626             else if (rc == ERROR_FILE_NOT_FOUND)
627             {
628                 ERR("Source File Not Found!  Continuing\n");
629                 rc = 0;
630             }
631             else if (file->Attributes & msidbFileAttributesVital)
632             {
633                 ERR("Ignoring Error and continuing (nonvital file)...\n");
634                 rc = 0;
635             }
636         }
637         else
638         {
639             file->state = msifs_installed;
640             rc = ERROR_SUCCESS;
641         }
642     }
643
644     /* cleanup */
645     free_media_info( mi );
646     return rc;
647 }
648
649 static UINT ITERATE_DuplicateFiles(MSIRECORD *row, LPVOID param)
650 {
651     MSIPACKAGE *package = (MSIPACKAGE*)param;
652     WCHAR dest_name[0x100];
653     LPWSTR dest_path, dest;
654     LPCWSTR file_key, component;
655     DWORD sz;
656     DWORD rc;
657     MSICOMPONENT *comp;
658     MSIFILE *file;
659
660     component = MSI_RecordGetString(row,2);
661     comp = get_loaded_component(package,component);
662
663     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ))
664     {
665         TRACE("Skipping copy due to disabled component %s\n",
666                         debugstr_w(component));
667
668         /* the action taken was the same as the current install state */        
669         comp->Action = comp->Installed;
670
671         return ERROR_SUCCESS;
672     }
673
674     comp->Action = INSTALLSTATE_LOCAL;
675
676     file_key = MSI_RecordGetString(row,3);
677     if (!file_key)
678     {
679         ERR("Unable to get file key\n");
680         return ERROR_FUNCTION_FAILED;
681     }
682
683     rc = get_file_target(package,file_key,&file);
684
685     if (rc != ERROR_SUCCESS)
686     {
687         ERR("Original file unknown %s\n",debugstr_w(file_key));
688         return ERROR_SUCCESS;
689     }
690
691     if (MSI_RecordIsNull(row,4))
692         strcpyW(dest_name,strrchrW(file->TargetPath,'\\')+1);
693     else
694     {
695         sz=0x100;
696         MSI_RecordGetStringW(row,4,dest_name,&sz);
697         reduce_to_longfilename(dest_name);
698     }
699
700     if (MSI_RecordIsNull(row,5))
701     {
702         LPWSTR p;
703         dest_path = strdupW(file->TargetPath);
704         p = strrchrW(dest_path,'\\');
705         if (p)
706             *p=0;
707     }
708     else
709     {
710         LPCWSTR destkey;
711         destkey = MSI_RecordGetString(row,5);
712         dest_path = resolve_folder(package, destkey, FALSE,FALSE,NULL);
713         if (!dest_path)
714         {
715             /* try a Property */
716             dest_path = msi_dup_property( package, destkey );
717             if (!dest_path)
718             {
719                 FIXME("Unable to get destination folder, try AppSearch properties\n");
720                 return ERROR_SUCCESS;
721             }
722         }
723     }
724
725     dest = build_directory_name(2, dest_path, dest_name);
726
727     TRACE("Duplicating file %s to %s\n",debugstr_w(file->TargetPath),
728                     debugstr_w(dest)); 
729
730     if (strcmpW(file->TargetPath,dest))
731         rc = !CopyFileW(file->TargetPath,dest,TRUE);
732     else
733         rc = ERROR_SUCCESS;
734
735     if (rc != ERROR_SUCCESS)
736         ERR("Failed to copy file %s -> %s, last error %ld\n",
737             debugstr_w(file->TargetPath), debugstr_w(dest_path), GetLastError());
738
739     FIXME("We should track these duplicate files as well\n");   
740
741     msi_free(dest_path);
742     msi_free(dest);
743
744     msi_file_update_ui(package, file, szDuplicateFiles);
745
746     return ERROR_SUCCESS;
747 }
748
749 UINT ACTION_DuplicateFiles(MSIPACKAGE *package)
750 {
751     UINT rc;
752     MSIQUERY * view;
753     static const WCHAR ExecSeqQuery[] =
754         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
755          '`','D','u','p','l','i','c','a','t','e','F','i','l','e','`',0};
756
757     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
758     if (rc != ERROR_SUCCESS)
759         return ERROR_SUCCESS;
760
761     rc = MSI_IterateRecords(view, NULL, ITERATE_DuplicateFiles, package);
762     msiobj_release(&view->hdr);
763
764     return rc;
765 }
766
767 UINT ACTION_RemoveFiles( MSIPACKAGE *package )
768 {
769     MSIFILE *file;
770
771     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
772     {
773         MSIRECORD *uirow;
774         LPWSTR uipath, p;
775
776         if ( !file->Component )
777             continue;
778         if ( file->Component->Installed == INSTALLSTATE_LOCAL )
779             continue;
780
781         if ( file->state == msifs_installed )
782             ERR("removing installed file %s\n", debugstr_w(file->TargetPath));
783
784         if ( file->state != msifs_present )
785             continue;
786
787         TRACE("removing %s\n", debugstr_w(file->File) );
788         if ( !DeleteFileW( file->TargetPath ) )
789             ERR("failed to delete %s\n",  debugstr_w(file->TargetPath) );
790         file->state = msifs_missing;
791
792         /* the UI chunk */
793         uirow = MSI_CreateRecord( 9 );
794         MSI_RecordSetStringW( uirow, 1, file->FileName );
795         uipath = strdupW( file->TargetPath );
796         p = strrchrW(uipath,'\\');
797         if (p)
798             p[1]=0;
799         MSI_RecordSetStringW( uirow, 9, uipath);
800         ui_actiondata( package, szRemoveFiles, uirow);
801         msiobj_release( &uirow->hdr );
802         msi_free( uipath );
803         /* FIXME: call ui_progress here? */
804     }
805
806     return ERROR_SUCCESS;
807 }