wined3d: Fix a bug in BtlFast which was uncovered by the 32-bit dibsection support.
[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 "msipriv.h"
43 #include "winuser.h"
44 #include "winreg.h"
45 #include "shlwapi.h"
46 #include "wine/unicode.h"
47
48 WINE_DEFAULT_DEBUG_CHANNEL(msi);
49
50 static void msi_file_update_ui( MSIPACKAGE *package, MSIFILE *f, const WCHAR *action )
51 {
52     MSIRECORD *uirow;
53     LPWSTR uipath, p;
54
55     /* the UI chunk */
56     uirow = MSI_CreateRecord( 9 );
57     MSI_RecordSetStringW( uirow, 1, f->FileName );
58     uipath = strdupW( f->TargetPath );
59     p = strrchrW(uipath,'\\');
60     if (p)
61         p[1]=0;
62     MSI_RecordSetStringW( uirow, 9, uipath);
63     MSI_RecordSetInteger( uirow, 6, f->FileSize );
64     ui_actiondata( package, action, uirow);
65     msiobj_release( &uirow->hdr );
66     msi_free( uipath );
67     ui_progress( package, 2, f->FileSize, 0, 0);
68 }
69
70 /* compares the version of a file read from the filesystem and
71  * the version specified in the File table
72  */
73 static int msi_compare_file_version(MSIFILE *file)
74 {
75     WCHAR version[MAX_PATH];
76     DWORD size;
77     UINT r;
78
79     size = MAX_PATH;
80     version[0] = '\0';
81     r = MsiGetFileVersionW(file->TargetPath, version, &size, NULL, NULL);
82     if (r != ERROR_SUCCESS)
83         return 0;
84
85     return lstrcmpW(version, file->Version);
86 }
87
88 static UINT get_file_target(MSIPACKAGE *package, LPCWSTR file_key, 
89                             MSIFILE** file)
90 {
91     LIST_FOR_EACH_ENTRY( *file, &package->files, MSIFILE, entry )
92     {
93         if (lstrcmpW( file_key, (*file)->File )==0)
94         {
95             if ((*file)->state >= msifs_overwrite)
96                 return ERROR_SUCCESS;
97             else
98                 return ERROR_FILE_NOT_FOUND;
99         }
100     }
101
102     return ERROR_FUNCTION_FAILED;
103 }
104
105 static void schedule_install_files(MSIPACKAGE *package)
106 {
107     MSIFILE *file;
108
109     LIST_FOR_EACH_ENTRY(file, &package->files, MSIFILE, entry)
110     {
111         if (!ACTION_VerifyComponentForAction(file->Component, INSTALLSTATE_LOCAL))
112         {
113             TRACE("File %s is not scheduled for install\n", debugstr_w(file->File));
114
115             ui_progress(package,2,file->FileSize,0,0);
116             file->state = msifs_skipped;
117         }
118     }
119 }
120
121 static UINT copy_file(MSIFILE *file, LPWSTR source)
122 {
123     BOOL ret;
124
125     ret = CopyFileW(source, file->TargetPath, FALSE);
126     if (!ret)
127         return GetLastError();
128
129     SetFileAttributesW(file->TargetPath, FILE_ATTRIBUTE_NORMAL);
130
131     file->state = msifs_installed;
132     return ERROR_SUCCESS;
133 }
134
135 static UINT copy_install_file(MSIPACKAGE *package, MSIFILE *file, LPWSTR source)
136 {
137     UINT gle;
138
139     TRACE("Copying %s to %s\n", debugstr_w(source),
140           debugstr_w(file->TargetPath));
141
142     gle = copy_file(file, source);
143     if (gle == ERROR_SUCCESS)
144         return gle;
145
146     if (gle == ERROR_ALREADY_EXISTS && file->state == msifs_overwrite)
147     {
148         TRACE("overwriting existing file\n");
149         return ERROR_SUCCESS;
150     }
151     else if (gle == ERROR_ACCESS_DENIED)
152     {
153         SetFileAttributesW(file->TargetPath, FILE_ATTRIBUTE_NORMAL);
154
155         gle = copy_file(file, source);
156         TRACE("Overwriting existing file: %d\n", gle);
157     }
158     if (gle == ERROR_SHARING_VIOLATION || gle == ERROR_USER_MAPPED_FILE)
159     {
160         WCHAR tmpfileW[MAX_PATH], *pathW, *p;
161         DWORD len;
162
163         TRACE("file in use, scheduling rename operation\n");
164
165         GetTempFileNameW(szBackSlash, szMsi, 0, tmpfileW);
166         len = strlenW(file->TargetPath) + strlenW(tmpfileW) + 1;
167         if (!(pathW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR))))
168             return ERROR_OUTOFMEMORY;
169
170         strcpyW(pathW, file->TargetPath);
171         if ((p = strrchrW(pathW, '\\'))) *p = 0;
172         strcatW(pathW, tmpfileW);
173
174         if (CopyFileW(source, pathW, FALSE) &&
175             MoveFileExW(file->TargetPath, NULL, MOVEFILE_DELAY_UNTIL_REBOOT) &&
176             MoveFileExW(pathW, file->TargetPath, MOVEFILE_DELAY_UNTIL_REBOOT))
177         {
178             file->state = msifs_installed;
179             package->need_reboot = 1;
180             gle = ERROR_SUCCESS;
181         }
182         else
183         {
184             gle = GetLastError();
185             WARN("failed to schedule rename operation: %d)\n", gle);
186         }
187         HeapFree(GetProcessHeap(), 0, pathW);
188     }
189
190     return gle;
191 }
192
193 static BOOL check_dest_hash_matches(MSIFILE *file)
194 {
195     MSIFILEHASHINFO hash;
196     UINT r;
197
198     if (!file->hash.dwFileHashInfoSize)
199         return FALSE;
200
201     hash.dwFileHashInfoSize = sizeof(MSIFILEHASHINFO);
202     r = MsiGetFileHashW(file->TargetPath, 0, &hash);
203     if (r != ERROR_SUCCESS)
204         return FALSE;
205
206     return !memcmp(&hash, &file->hash, sizeof(MSIFILEHASHINFO));
207 }
208
209 static BOOL installfiles_cb(MSIPACKAGE *package, LPCWSTR file, DWORD action,
210                             LPWSTR *path, DWORD *attrs, PVOID user)
211 {
212     static MSIFILE *f = NULL;
213
214     if (action == MSICABEXTRACT_BEGINEXTRACT)
215     {
216         f = get_loaded_file(package, file);
217         if (!f)
218         {
219             WARN("unknown file in cabinet (%s)\n", debugstr_w(file));
220             return FALSE;
221         }
222
223         if (f->state != msifs_missing && f->state != msifs_overwrite)
224         {
225             TRACE("Skipping extraction of %s\n", debugstr_w(file));
226             return FALSE;
227         }
228
229         msi_file_update_ui(package, f, szInstallFiles);
230
231         *path = strdupW(f->TargetPath);
232         *attrs = f->Attributes;
233     }
234     else if (action == MSICABEXTRACT_FILEEXTRACTED)
235     {
236         f->state = msifs_installed;
237         f = NULL;
238     }
239
240     return TRUE;
241 }
242
243 /*
244  * ACTION_InstallFiles()
245  * 
246  * For efficiency, this is done in two passes:
247  * 1) Correct all the TargetPaths and determine what files are to be installed.
248  * 2) Extract Cabinets and copy files.
249  */
250 UINT ACTION_InstallFiles(MSIPACKAGE *package)
251 {
252     MSIMEDIAINFO *mi;
253     UINT rc = ERROR_SUCCESS;
254     MSIFILE *file;
255
256     /* increment progress bar each time action data is sent */
257     ui_progress(package,1,1,0,0);
258
259     schedule_install_files(package);
260
261     /*
262      * Despite MSDN specifying that the CreateFolders action
263      * should be called before InstallFiles, some installers don't
264      * do that, and they seem to work correctly.  We need to create
265      * directories here to make sure that the files can be copied.
266      */
267     msi_create_component_directories( package );
268
269     mi = msi_alloc_zero( sizeof(MSIMEDIAINFO) );
270
271     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
272     {
273         if (file->state != msifs_missing && !mi->is_continuous && file->state != msifs_overwrite)
274             continue;
275
276         if (check_dest_hash_matches(file))
277         {
278             TRACE("File hashes match, not overwriting\n");
279             continue;
280         }
281
282         if (MsiGetFileVersionW(file->TargetPath, NULL, NULL, NULL, NULL) == ERROR_SUCCESS &&
283             msi_compare_file_version(file) >= 0)
284         {
285             TRACE("Destination file version greater, not overwriting\n");
286             continue;
287         }
288
289         if (file->Sequence > mi->last_sequence || mi->is_continuous ||
290             (file->IsCompressed && !mi->is_extracted))
291         {
292             MSICABDATA data;
293
294             rc = ready_media(package, file, mi);
295             if (rc != ERROR_SUCCESS)
296             {
297                 ERR("Failed to ready media\n");
298                 break;
299             }
300
301             data.mi = mi;
302             data.package = package;
303             data.cb = installfiles_cb;
304             data.user = NULL;
305
306             if (file->IsCompressed &&
307                 !msi_cabextract(package, mi, &data))
308             {
309                 ERR("Failed to extract cabinet: %s\n", debugstr_w(mi->cabinet));
310                 rc = ERROR_FUNCTION_FAILED;
311                 break;
312             }
313         }
314
315         if (!file->IsCompressed)
316         {
317             LPWSTR source = resolve_file_source(package, file);
318
319             TRACE("file paths %s to %s\n", debugstr_w(source),
320                   debugstr_w(file->TargetPath));
321
322             msi_file_update_ui(package, file, szInstallFiles);
323             rc = copy_install_file(package, file, source);
324             if (rc != ERROR_SUCCESS)
325             {
326                 ERR("Failed to copy %s to %s (%d)\n", debugstr_w(source),
327                     debugstr_w(file->TargetPath), rc);
328                 rc = ERROR_INSTALL_FAILURE;
329                 msi_free(source);
330                 break;
331             }
332
333             msi_free(source);
334         }
335         else if (file->state != msifs_installed)
336         {
337             ERR("compressed file wasn't extracted (%s)\n",
338                 debugstr_w(file->TargetPath));
339             rc = ERROR_INSTALL_FAILURE;
340             break;
341         }
342     }
343
344     msi_free_media_info(mi);
345     return rc;
346 }
347
348 static UINT ITERATE_DuplicateFiles(MSIRECORD *row, LPVOID param)
349 {
350     MSIPACKAGE *package = param;
351     WCHAR dest_name[0x100];
352     LPWSTR dest_path, dest;
353     LPCWSTR file_key, component;
354     DWORD sz;
355     DWORD rc;
356     MSICOMPONENT *comp;
357     MSIFILE *file;
358
359     component = MSI_RecordGetString(row,2);
360     comp = get_loaded_component(package,component);
361
362     if (!ACTION_VerifyComponentForAction( comp, INSTALLSTATE_LOCAL ))
363     {
364         TRACE("Skipping copy due to disabled component %s\n",
365                         debugstr_w(component));
366
367         /* the action taken was the same as the current install state */        
368         comp->Action = comp->Installed;
369
370         return ERROR_SUCCESS;
371     }
372
373     comp->Action = INSTALLSTATE_LOCAL;
374
375     file_key = MSI_RecordGetString(row,3);
376     if (!file_key)
377     {
378         ERR("Unable to get file key\n");
379         return ERROR_FUNCTION_FAILED;
380     }
381
382     rc = get_file_target(package,file_key,&file);
383
384     if (rc != ERROR_SUCCESS)
385     {
386         ERR("Original file unknown %s\n",debugstr_w(file_key));
387         return ERROR_SUCCESS;
388     }
389
390     if (MSI_RecordIsNull(row,4))
391         strcpyW(dest_name,strrchrW(file->TargetPath,'\\')+1);
392     else
393     {
394         sz=0x100;
395         MSI_RecordGetStringW(row,4,dest_name,&sz);
396         reduce_to_longfilename(dest_name);
397     }
398
399     if (MSI_RecordIsNull(row,5))
400     {
401         LPWSTR p;
402         dest_path = strdupW(file->TargetPath);
403         p = strrchrW(dest_path,'\\');
404         if (p)
405             *p=0;
406     }
407     else
408     {
409         LPCWSTR destkey;
410         destkey = MSI_RecordGetString(row,5);
411         dest_path = resolve_folder(package, destkey, FALSE, FALSE, TRUE, NULL);
412         if (!dest_path)
413         {
414             /* try a Property */
415             dest_path = msi_dup_property( package, destkey );
416             if (!dest_path)
417             {
418                 FIXME("Unable to get destination folder, try AppSearch properties\n");
419                 return ERROR_SUCCESS;
420             }
421         }
422     }
423
424     dest = build_directory_name(2, dest_path, dest_name);
425     create_full_pathW(dest_path);
426
427     TRACE("Duplicating file %s to %s\n",debugstr_w(file->TargetPath),
428                     debugstr_w(dest)); 
429
430     if (strcmpW(file->TargetPath,dest))
431         rc = !CopyFileW(file->TargetPath,dest,TRUE);
432     else
433         rc = ERROR_SUCCESS;
434
435     if (rc != ERROR_SUCCESS)
436         ERR("Failed to copy file %s -> %s, last error %d\n",
437             debugstr_w(file->TargetPath), debugstr_w(dest_path), GetLastError());
438
439     FIXME("We should track these duplicate files as well\n");   
440
441     msi_free(dest_path);
442     msi_free(dest);
443
444     msi_file_update_ui(package, file, szDuplicateFiles);
445
446     return ERROR_SUCCESS;
447 }
448
449 UINT ACTION_DuplicateFiles(MSIPACKAGE *package)
450 {
451     UINT rc;
452     MSIQUERY * view;
453     static const WCHAR ExecSeqQuery[] =
454         {'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
455          '`','D','u','p','l','i','c','a','t','e','F','i','l','e','`',0};
456
457     rc = MSI_DatabaseOpenViewW(package->db, ExecSeqQuery, &view);
458     if (rc != ERROR_SUCCESS)
459         return ERROR_SUCCESS;
460
461     rc = MSI_IterateRecords(view, NULL, ITERATE_DuplicateFiles, package);
462     msiobj_release(&view->hdr);
463
464     return rc;
465 }
466
467 static BOOL verify_comp_for_removal(MSICOMPONENT *comp, UINT install_mode)
468 {
469     INSTALLSTATE request = comp->ActionRequest;
470
471     if (request == INSTALLSTATE_UNKNOWN)
472         return FALSE;
473
474     if (install_mode == msidbRemoveFileInstallModeOnInstall &&
475         (request == INSTALLSTATE_LOCAL || request == INSTALLSTATE_SOURCE))
476         return TRUE;
477
478     if (request == INSTALLSTATE_ABSENT)
479     {
480         if (!comp->ComponentId)
481             return FALSE;
482
483         if (install_mode == msidbRemoveFileInstallModeOnRemove)
484             return TRUE;
485     }
486
487     if (install_mode == msidbRemoveFileInstallModeOnBoth)
488         return TRUE;
489
490     return FALSE;
491 }
492
493 static UINT ITERATE_RemoveFiles(MSIRECORD *row, LPVOID param)
494 {
495     MSIPACKAGE *package = param;
496     MSICOMPONENT *comp;
497     LPCWSTR component, filename, dirprop;
498     UINT install_mode;
499     LPWSTR dir = NULL, path = NULL;
500     DWORD size;
501     UINT r;
502
503     component = MSI_RecordGetString(row, 2);
504     filename = MSI_RecordGetString(row, 3);
505     dirprop = MSI_RecordGetString(row, 4);
506     install_mode = MSI_RecordGetInteger(row, 5);
507
508     comp = get_loaded_component(package, component);
509     if (!comp)
510     {
511         ERR("Invalid component: %s\n", debugstr_w(component));
512         return ERROR_FUNCTION_FAILED;
513     }
514
515     if (!verify_comp_for_removal(comp, install_mode))
516     {
517         TRACE("Skipping removal due to missing conditions\n");
518         comp->Action = comp->Installed;
519         return ERROR_SUCCESS;
520     }
521
522     dir = msi_dup_property(package, dirprop);
523     if (!dir)
524         return ERROR_OUTOFMEMORY;
525
526     size = (filename != NULL) ? lstrlenW(filename) : 0;
527     size += lstrlenW(dir) + 2;
528     path = msi_alloc(size * sizeof(WCHAR));
529     if (!path)
530     {
531         r = ERROR_OUTOFMEMORY;
532         goto done;
533     }
534
535     lstrcpyW(path, dir);
536     PathAddBackslashW(path);
537
538     if (filename)
539     {
540         lstrcatW(path, filename);
541
542         TRACE("Deleting misc file: %s\n", debugstr_w(path));
543         DeleteFileW(path);
544     }
545     else
546     {
547         TRACE("Removing misc directory: %s\n", debugstr_w(path));
548         RemoveDirectoryW(path);
549     }
550
551 done:
552     msi_free(path);
553     msi_free(dir);
554     return ERROR_SUCCESS;
555 }
556
557 UINT ACTION_RemoveFiles( MSIPACKAGE *package )
558 {
559     MSIQUERY *view;
560     MSIFILE *file;
561     UINT r;
562
563     static const WCHAR query[] = {
564         'S','E','L','E','C','T',' ','*',' ','F','R','O','M',' ',
565         '`','R','e','m','o','v','e','F','i','l','e','`',0};
566
567     r = MSI_DatabaseOpenViewW(package->db, query, &view);
568     if (r == ERROR_SUCCESS)
569     {
570         MSI_IterateRecords(view, NULL, ITERATE_RemoveFiles, package);
571         msiobj_release(&view->hdr);
572     }
573
574     LIST_FOR_EACH_ENTRY( file, &package->files, MSIFILE, entry )
575     {
576         MSIRECORD *uirow;
577         LPWSTR uipath, p;
578
579         if ( file->state == msifs_installed )
580             ERR("removing installed file %s\n", debugstr_w(file->TargetPath));
581
582         if ( file->Component->ActionRequest != INSTALLSTATE_ABSENT ||
583              file->Component->Installed == INSTALLSTATE_SOURCE )
584             continue;
585
586         /* don't remove a file if the old file
587          * is strictly newer than the version to be installed
588          */
589         if ( msi_compare_file_version( file ) < 0 )
590             continue;
591
592         TRACE("removing %s\n", debugstr_w(file->File) );
593         if ( !DeleteFileW( file->TargetPath ) )
594             TRACE("failed to delete %s\n",  debugstr_w(file->TargetPath));
595         file->state = msifs_missing;
596
597         /* the UI chunk */
598         uirow = MSI_CreateRecord( 9 );
599         MSI_RecordSetStringW( uirow, 1, file->FileName );
600         uipath = strdupW( file->TargetPath );
601         p = strrchrW(uipath,'\\');
602         if (p)
603             p[1]=0;
604         MSI_RecordSetStringW( uirow, 9, uipath);
605         ui_actiondata( package, szRemoveFiles, uirow);
606         msiobj_release( &uirow->hdr );
607         msi_free( uipath );
608         /* FIXME: call ui_progress here? */
609     }
610
611     return ERROR_SUCCESS;
612 }