wined3d: Add a WARN to IWineD3DDeviceImpl_SetFrontBackBuffers() about potentially...
[wine] / dlls / advpack / files.c
1 /*
2  * Advpack file functions
3  *
4  * Copyright 2006 James Hawkins
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 #include <stdarg.h>
22 #include <stdlib.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winuser.h"
27 #include "winreg.h"
28 #include "winver.h"
29 #include "winternl.h"
30 #include "setupapi.h"
31 #include "advpub.h"
32 #include "fdi.h"
33 #include "wine/debug.h"
34 #include "wine/unicode.h"
35 #include "advpack_private.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(advpack);
38
39 /* converts an ansi double null-terminated list to a unicode list */
40 static LPWSTR ansi_to_unicode_list(LPCSTR ansi_list)
41 {
42     DWORD len, wlen = 0;
43     LPWSTR list;
44     LPCSTR ptr = ansi_list;
45
46     while (*ptr) ptr += lstrlenA(ptr) + 1;
47     len = ptr + 1 - ansi_list;
48     wlen = MultiByteToWideChar(CP_ACP, 0, ansi_list, len, NULL, 0);
49     list = HeapAlloc(GetProcessHeap(), 0, wlen * sizeof(WCHAR));
50     MultiByteToWideChar(CP_ACP, 0, ansi_list, len, list, wlen);
51     return list;
52 }
53
54 /***********************************************************************
55  *      AddDelBackupEntryA (ADVPACK.@)
56  *
57  * See AddDelBackupEntryW.
58  */
59 HRESULT WINAPI AddDelBackupEntryA(LPCSTR lpcszFileList, LPCSTR lpcszBackupDir,
60                                   LPCSTR lpcszBaseName, DWORD dwFlags)
61 {
62     UNICODE_STRING backupdir, basename;
63     LPWSTR filelist;
64     LPCWSTR backup;
65     HRESULT res;
66
67     TRACE("(%s, %s, %s, %d)\n", debugstr_a(lpcszFileList),
68           debugstr_a(lpcszBackupDir), debugstr_a(lpcszBaseName), dwFlags);
69
70     if (lpcszFileList)
71         filelist = ansi_to_unicode_list(lpcszFileList);
72     else
73         filelist = NULL;
74
75     RtlCreateUnicodeStringFromAsciiz(&backupdir, lpcszBackupDir);
76     RtlCreateUnicodeStringFromAsciiz(&basename, lpcszBaseName);
77
78     if (lpcszBackupDir)
79         backup = backupdir.Buffer;
80     else
81         backup = NULL;
82
83     res = AddDelBackupEntryW(filelist, backup, basename.Buffer, dwFlags);
84
85     HeapFree(GetProcessHeap(), 0, filelist);
86
87     RtlFreeUnicodeString(&backupdir);
88     RtlFreeUnicodeString(&basename);
89
90     return res;
91 }
92
93 /***********************************************************************
94  *      AddDelBackupEntryW (ADVPACK.@)
95  *
96  * Either appends the files in the file list to the backup section of
97  * the specified INI, or deletes the entries from the INI file.
98  *
99  * PARAMS
100  *   lpcszFileList  [I] NULL-separated list of filenames.
101  *   lpcszBackupDir [I] Path of the backup directory.
102  *   lpcszBaseName  [I] Basename of the INI file.
103  *   dwFlags        [I] AADBE_ADD_ENTRY adds the entries in the file list
104  *                      to the INI file, while AADBE_DEL_ENTRY removes
105  *                      the entries from the INI file.
106  *
107  * RETURNS
108  *   S_OK in all cases.
109  *
110  * NOTES
111  *   If the INI file does not exist before adding entries to it, the file
112  *   will be created.
113  * 
114  *   If lpcszBackupDir is NULL, the INI file is assumed to exist in
115  *   c:\windows or created there if it does not exist.
116  */
117 HRESULT WINAPI AddDelBackupEntryW(LPCWSTR lpcszFileList, LPCWSTR lpcszBackupDir,
118                                   LPCWSTR lpcszBaseName, DWORD dwFlags)
119 {
120     WCHAR szIniPath[MAX_PATH];
121     LPCWSTR szString = NULL;
122
123     static const WCHAR szBackupEntry[] = {
124         '-','1',',','0',',','0',',','0',',','0',',','0',',','-','1',0
125     };
126     
127     static const WCHAR backslash[] = {'\\',0};
128     static const WCHAR ini[] = {'.','i','n','i',0};
129     static const WCHAR backup[] = {'b','a','c','k','u','p',0};
130
131     TRACE("(%s, %s, %s, %d)\n", debugstr_w(lpcszFileList),
132           debugstr_w(lpcszBackupDir), debugstr_w(lpcszBaseName), dwFlags);
133
134     if (!lpcszFileList || !*lpcszFileList)
135         return S_OK;
136
137     if (lpcszBackupDir)
138         lstrcpyW(szIniPath, lpcszBackupDir);
139     else
140         GetWindowsDirectoryW(szIniPath, MAX_PATH);
141
142     lstrcatW(szIniPath, backslash);
143     lstrcatW(szIniPath, lpcszBaseName);
144     lstrcatW(szIniPath, ini);
145
146     SetFileAttributesW(szIniPath, FILE_ATTRIBUTE_NORMAL);
147
148     if (dwFlags & AADBE_ADD_ENTRY)
149         szString = szBackupEntry;
150     else if (dwFlags & AADBE_DEL_ENTRY)
151         szString = NULL;
152
153     /* add or delete the INI entries */
154     while (*lpcszFileList)
155     {
156         WritePrivateProfileStringW(backup, lpcszFileList, szString, szIniPath);
157         lpcszFileList += lstrlenW(lpcszFileList) + 1;
158     }
159
160     /* hide the INI file */
161     SetFileAttributesW(szIniPath, FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN);
162
163     return S_OK;
164 }
165
166 /* FIXME: this is only for the local case, X:\ */
167 #define ROOT_LENGTH 3
168
169 static UINT CALLBACK pQuietQueueCallback(PVOID Context, UINT Notification,
170                                          UINT_PTR Param1, UINT_PTR Param2)
171 {
172     return 1;
173 }
174
175 static UINT CALLBACK pQueueCallback(PVOID Context, UINT Notification,
176                                     UINT_PTR Param1, UINT_PTR Param2)
177 {
178     /* only be verbose for error notifications */
179     if (!Notification ||
180         Notification == SPFILENOTIFY_RENAMEERROR ||
181         Notification == SPFILENOTIFY_DELETEERROR ||
182         Notification == SPFILENOTIFY_COPYERROR)
183     {
184         return SetupDefaultQueueCallbackW(Context, Notification,
185                                           Param1, Param2);
186     }
187
188     return 1;
189 }
190
191 /***********************************************************************
192  *      AdvInstallFileA (ADVPACK.@)
193  *
194  * See AdvInstallFileW.
195  */
196 HRESULT WINAPI AdvInstallFileA(HWND hwnd, LPCSTR lpszSourceDir, LPCSTR lpszSourceFile,
197                                LPCSTR lpszDestDir, LPCSTR lpszDestFile,
198                                DWORD dwFlags, DWORD dwReserved)
199 {
200     UNICODE_STRING sourcedir, sourcefile;
201     UNICODE_STRING destdir, destfile;
202     HRESULT res;
203
204     TRACE("(%p, %s, %s, %s, %s, %d, %d)\n", hwnd, debugstr_a(lpszSourceDir),
205           debugstr_a(lpszSourceFile), debugstr_a(lpszDestDir),
206           debugstr_a(lpszDestFile), dwFlags, dwReserved);
207
208     if (!lpszSourceDir || !lpszSourceFile || !lpszDestDir)
209         return E_INVALIDARG;
210
211     RtlCreateUnicodeStringFromAsciiz(&sourcedir, lpszSourceDir);
212     RtlCreateUnicodeStringFromAsciiz(&sourcefile, lpszSourceFile);
213     RtlCreateUnicodeStringFromAsciiz(&destdir, lpszDestDir);
214     RtlCreateUnicodeStringFromAsciiz(&destfile, lpszDestFile);
215
216     res = AdvInstallFileW(hwnd, sourcedir.Buffer, sourcefile.Buffer,
217                           destdir.Buffer, destfile.Buffer, dwFlags, dwReserved);
218
219     RtlFreeUnicodeString(&sourcedir);
220     RtlFreeUnicodeString(&sourcefile);
221     RtlFreeUnicodeString(&destdir);
222     RtlFreeUnicodeString(&destfile);
223
224     return res;
225 }
226
227 /***********************************************************************
228  *      AdvInstallFileW (ADVPACK.@)
229  *
230  * Copies a file from the source to a destination.
231  *
232  * PARAMS
233  *   hwnd           [I] Handle to the window used for messages.
234  *   lpszSourceDir  [I] Source directory.
235  *   lpszSourceFile [I] Source filename.
236  *   lpszDestDir    [I] Destination directory.
237  *   lpszDestFile   [I] Optional destination filename.
238  *   dwFlags        [I] See advpub.h.
239  *   dwReserved     [I] Reserved.  Must be 0.
240  *
241  * RETURNS
242  *   Success: S_OK.
243  *   Failure: E_FAIL.
244  *
245  * NOTES
246  *   If lpszDestFile is NULL, the destination filename is the same as
247  *   lpszSourceFIle.
248  */
249 HRESULT WINAPI AdvInstallFileW(HWND hwnd, LPCWSTR lpszSourceDir, LPCWSTR lpszSourceFile,
250                                LPCWSTR lpszDestDir, LPCWSTR lpszDestFile,
251                                DWORD dwFlags, DWORD dwReserved)
252 {
253     PSP_FILE_CALLBACK_W pFileCallback;
254     LPWSTR szDestFilename;
255     LPCWSTR szPath;
256     WCHAR szRootPath[ROOT_LENGTH];
257     DWORD dwLen, dwLastError;
258     HSPFILEQ fileQueue;
259     PVOID pContext;
260
261     TRACE("(%p, %s, %s, %s, %s, %d, %d)\n", hwnd, debugstr_w(lpszSourceDir),
262           debugstr_w(lpszSourceFile), debugstr_w(lpszDestDir),
263           debugstr_w(lpszDestFile), dwFlags, dwReserved);
264
265     if (!lpszSourceDir || !lpszSourceFile || !lpszDestDir)
266         return E_INVALIDARG;
267         
268     fileQueue = SetupOpenFileQueue();
269     if (fileQueue == INVALID_HANDLE_VALUE)
270         return HRESULT_FROM_WIN32(GetLastError());
271
272     pContext = NULL;
273     dwLastError = ERROR_SUCCESS;
274
275     lstrcpynW(szRootPath, lpszSourceDir, ROOT_LENGTH);
276     szPath = lpszSourceDir + ROOT_LENGTH;
277
278     /* use lpszSourceFile as destination filename if lpszDestFile is NULL */
279     if (lpszDestFile)
280     {
281         dwLen = lstrlenW(lpszDestFile);
282         szDestFilename = HeapAlloc(GetProcessHeap(), 0, dwLen * sizeof(WCHAR));
283         lstrcpyW(szDestFilename, lpszDestFile);
284     }
285     else
286     {
287         dwLen = lstrlenW(lpszSourceFile);
288         szDestFilename = HeapAlloc(GetProcessHeap(), 0, dwLen * sizeof(WCHAR));
289         lstrcpyW(szDestFilename, lpszSourceFile);
290     }
291
292     /* add the file copy operation to the setup queue */
293     if (!SetupQueueCopyW(fileQueue, szRootPath, szPath, lpszSourceFile, NULL,
294                          NULL, lpszDestDir, szDestFilename, dwFlags))
295     {
296         dwLastError = GetLastError();
297         goto done;
298     }
299
300     pContext = SetupInitDefaultQueueCallbackEx(hwnd, INVALID_HANDLE_VALUE,
301                                                0, 0, NULL);
302     if (!pContext)
303     {
304         dwLastError = GetLastError();
305         goto done;
306     }
307
308     /* don't output anything for AIF_QUIET */
309     if (dwFlags & AIF_QUIET)
310         pFileCallback = pQuietQueueCallback;
311     else
312         pFileCallback = pQueueCallback;
313
314     /* perform the file copy */
315     if (!SetupCommitFileQueueW(hwnd, fileQueue, pFileCallback, pContext))
316     {
317         dwLastError = GetLastError();
318         goto done;
319     }
320
321 done:
322     SetupTermDefaultQueueCallback(pContext);
323     SetupCloseFileQueue(fileQueue);
324     
325     HeapFree(GetProcessHeap(), 0, szDestFilename);
326     
327     return HRESULT_FROM_WIN32(dwLastError);
328 }
329
330 static HRESULT DELNODE_recurse_dirtree(LPWSTR fname, DWORD flags)
331 {
332     DWORD fattrs = GetFileAttributesW(fname);
333     HRESULT ret = E_FAIL;
334
335     static const WCHAR asterisk[] = {'*',0};
336     static const WCHAR dot[] = {'.',0};
337     static const WCHAR dotdot[] = {'.','.',0};
338
339     if (fattrs & FILE_ATTRIBUTE_DIRECTORY)
340     {
341         HANDLE hFindFile;
342         WIN32_FIND_DATAW w32fd;
343         BOOL done = TRUE;
344         int fname_len = lstrlenW(fname);
345
346         /* Generate a path with wildcard suitable for iterating */
347         if (fname_len && fname[fname_len-1] != '\\') fname[fname_len++] = '\\';
348         lstrcpyW(fname + fname_len, asterisk);
349
350         if ((hFindFile = FindFirstFileW(fname, &w32fd)) != INVALID_HANDLE_VALUE)
351         {
352             /* Iterate through the files in the directory */
353             for (done = FALSE; !done; done = !FindNextFileW(hFindFile, &w32fd))
354             {
355                 TRACE("%s\n", debugstr_w(w32fd.cFileName));
356                 if (lstrcmpW(dot, w32fd.cFileName) != 0 &&
357                     lstrcmpW(dotdot, w32fd.cFileName) != 0)
358                 {
359                     lstrcpyW(fname + fname_len, w32fd.cFileName);
360                     if (DELNODE_recurse_dirtree(fname, flags) != S_OK)
361                     {
362                         break; /* Failure */
363                     }
364                 }
365             }
366             FindClose(hFindFile);
367         }
368
369         /* We're done with this directory, so restore the old path without wildcard */
370         *(fname + fname_len) = '\0';
371
372         if (done)
373         {
374             TRACE("%s: directory\n", debugstr_w(fname));
375             if (SetFileAttributesW(fname, FILE_ATTRIBUTE_NORMAL) && RemoveDirectoryW(fname))
376             {
377                 ret = S_OK;
378             }
379         }
380     }
381     else
382     {
383         TRACE("%s: file\n", debugstr_w(fname));
384         if (SetFileAttributesW(fname, FILE_ATTRIBUTE_NORMAL) && DeleteFileW(fname))
385         {
386             ret = S_OK;
387         }
388     }
389     
390     return ret;
391 }
392
393 /***********************************************************************
394  *              DelNodeA   (ADVPACK.@)
395  *
396  * See DelNodeW.
397  */
398 HRESULT WINAPI DelNodeA(LPCSTR pszFileOrDirName, DWORD dwFlags)
399 {
400     UNICODE_STRING fileordirname;
401     HRESULT res;
402
403     TRACE("(%s, %d)\n", debugstr_a(pszFileOrDirName), dwFlags);
404
405     RtlCreateUnicodeStringFromAsciiz(&fileordirname, pszFileOrDirName);
406
407     res = DelNodeW(fileordirname.Buffer, dwFlags);
408
409     RtlFreeUnicodeString(&fileordirname);
410
411     return res;
412 }
413
414 /***********************************************************************
415  *              DelNodeW   (ADVPACK.@)
416  *
417  * Deletes a file or directory
418  *
419  * PARAMS
420  *   pszFileOrDirName   [I] Name of file or directory to delete
421  *   dwFlags            [I] Flags; see include/advpub.h
422  *
423  * RETURNS 
424  *   Success: S_OK
425  *   Failure: E_FAIL
426  *
427  * BUGS
428  *   - Ignores flags
429  *   - Native version apparently does a lot of checking to make sure
430  *     we're not trying to delete a system directory etc.
431  */
432 HRESULT WINAPI DelNodeW(LPCWSTR pszFileOrDirName, DWORD dwFlags)
433 {
434     WCHAR fname[MAX_PATH];
435     HRESULT ret = E_FAIL;
436     
437     TRACE("(%s, %d)\n", debugstr_w(pszFileOrDirName), dwFlags);
438     
439     if (dwFlags)
440         FIXME("Flags ignored!\n");
441
442     if (pszFileOrDirName && *pszFileOrDirName)
443     {
444         lstrcpyW(fname, pszFileOrDirName);
445
446         /* TODO: Should check for system directory deletion etc. here */
447
448         ret = DELNODE_recurse_dirtree(fname, dwFlags);
449     }
450
451     return ret;
452 }
453
454 /***********************************************************************
455  *             DelNodeRunDLL32A   (ADVPACK.@)
456  *
457  * See DelNodeRunDLL32W.
458  */
459 HRESULT WINAPI DelNodeRunDLL32A(HWND hWnd, HINSTANCE hInst, LPSTR cmdline, INT show)
460 {
461     UNICODE_STRING params;
462     HRESULT hr;
463
464     TRACE("(%p, %p, %s, %i)\n", hWnd, hInst, debugstr_a(cmdline), show);
465
466     RtlCreateUnicodeStringFromAsciiz(&params, cmdline);
467
468     hr = DelNodeRunDLL32W(hWnd, hInst, params.Buffer, show);
469
470     RtlFreeUnicodeString(&params);
471
472     return hr;
473 }
474
475 /***********************************************************************
476  *             DelNodeRunDLL32W   (ADVPACK.@)
477  *
478  * Deletes a file or directory, WinMain style.
479  *
480  * PARAMS
481  *   hWnd    [I] Handle to the window used for the display.
482  *   hInst   [I] Instance of the process.
483  *   cmdline [I] Contains parameters in the order FileOrDirName,Flags.
484  *   show    [I] How the window should be shown.
485  *
486  * RETURNS
487  *   Success: S_OK.
488  *   Failure: E_FAIL.
489  */
490 HRESULT WINAPI DelNodeRunDLL32W(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT show)
491 {
492     LPWSTR szFilename, szFlags;
493     LPWSTR cmdline_copy, cmdline_ptr;
494     DWORD dwFlags = 0;
495     HRESULT res;
496
497     TRACE("(%p, %p, %s, %i)\n", hWnd, hInst, debugstr_w(cmdline), show);
498
499     cmdline_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(cmdline) + 1) * sizeof(WCHAR));
500     cmdline_ptr = cmdline_copy;
501     lstrcpyW(cmdline_copy, cmdline);
502
503     /* get the parameters at indexes 0 and 1 respectively */
504     szFilename = get_parameter(&cmdline_ptr, ',');
505     szFlags = get_parameter(&cmdline_ptr, ',');
506
507     if (szFlags)
508         dwFlags = atolW(szFlags);
509
510     res = DelNodeW(szFilename, dwFlags);
511
512     HeapFree(GetProcessHeap(), 0, cmdline_copy);
513
514     return res;
515 }
516
517 /* The following definitions were copied from dlls/cabinet/cabinet.h */
518
519 /* SESSION Operation */
520 #define EXTRACT_FILLFILELIST  0x00000001
521 #define EXTRACT_EXTRACTFILES  0x00000002
522
523 struct FILELIST{
524     LPSTR FileName;
525     struct FILELIST *next;
526     BOOL DoExtract;
527 };
528
529 typedef struct {
530     INT FileSize;
531     ERF Error;
532     struct FILELIST *FileList;
533     INT FileCount;
534     INT Operation;
535     CHAR Destination[MAX_PATH];
536     CHAR CurrentFile[MAX_PATH];
537     CHAR Reserved[MAX_PATH];
538     struct FILELIST *FilterList;
539 } SESSION;
540
541 static HRESULT (WINAPI *pExtract)(SESSION*, LPCSTR);
542
543 /* removes legal characters before and after file list, and
544  * converts the file list to a NULL-separated list
545  */
546 static LPSTR convert_file_list(LPCSTR FileList, DWORD *dwNumFiles)
547 {
548     DWORD dwLen;
549     const char *first = FileList;
550     const char *last = FileList + strlen(FileList) - 1;
551     LPSTR szConvertedList, temp;
552     
553     /* any number of these chars before the list is OK */
554     while (first < last && (*first == ' ' || *first == '\t' || *first == ':'))
555         first++;
556
557     /* any number of these chars after the list is OK */
558     while (last > first && (*last == ' ' || *last == '\t' || *last == ':'))
559         last--;
560
561     if (first == last)
562         return NULL;
563
564     dwLen = last - first + 3; /* room for double-null termination */
565     szConvertedList = HeapAlloc(GetProcessHeap(), 0, dwLen);
566     lstrcpynA(szConvertedList, first, dwLen - 1);
567     szConvertedList[dwLen - 1] = '\0';
568
569     /* empty list */
570     if (!lstrlenA(szConvertedList))
571     {
572         HeapFree(GetProcessHeap(), 0, szConvertedList);
573         return NULL;
574     }
575         
576     *dwNumFiles = 1;
577
578     /* convert the colons to double-null termination */
579     temp = szConvertedList;
580     while (*temp)
581     {
582         if (*temp == ':')
583         {
584             *temp = '\0';
585             (*dwNumFiles)++;
586         }
587
588         temp++;
589     }
590
591     return szConvertedList;
592 }
593
594 static void free_file_node(struct FILELIST *pNode)
595 {
596     HeapFree(GetProcessHeap(), 0, pNode->FileName);
597     HeapFree(GetProcessHeap(), 0, pNode);
598 }
599
600 /* determines whether szFile is in the NULL-separated szFileList */
601 static BOOL file_in_list(LPCSTR szFile, LPCSTR szFileList)
602 {
603     DWORD dwLen = lstrlenA(szFile);
604     DWORD dwTestLen;
605
606     while (*szFileList)
607     {
608         dwTestLen = lstrlenA(szFileList);
609
610         if (dwTestLen == dwLen)
611         {
612             if (!lstrcmpiA(szFile, szFileList))
613                 return TRUE;
614         }
615
616         szFileList += dwTestLen + 1;
617     }
618
619     return FALSE;
620 }
621
622
623 /* returns the number of files that are in both the linked list and szFileList */
624 static DWORD fill_file_list(SESSION *session, LPCSTR szCabName, LPCSTR szFileList)
625 {
626     DWORD dwNumFound = 0;
627     struct FILELIST *pNode;
628
629     session->Operation |= EXTRACT_FILLFILELIST;
630     if (pExtract(session, szCabName) != S_OK)
631     {
632         session->Operation &= ~EXTRACT_FILLFILELIST;
633         return -1;
634     }
635
636     pNode = session->FileList;
637     while (pNode)
638     {
639         if (!file_in_list(pNode->FileName, szFileList))
640             pNode->DoExtract = FALSE;
641         else
642             dwNumFound++;
643
644         pNode = pNode->next;
645     }
646
647     session->Operation &= ~EXTRACT_FILLFILELIST;
648     return dwNumFound;
649 }
650
651 /***********************************************************************
652  *             ExtractFilesA    (ADVPACK.@)
653  *
654  * Extracts the specified files from a cab archive into
655  * a destination directory.
656  *
657  * PARAMS
658  *   CabName   [I] Filename of the cab archive.
659  *   ExpandDir [I] Destination directory for the extracted files.
660  *   Flags     [I] Reserved.
661  *   FileList  [I] Optional list of files to extract.  See NOTES.
662  *   LReserved [I] Reserved.  Must be NULL.
663  *   Reserved  [I] Reserved.  Must be 0.
664  *
665  * RETURNS
666  *   Success: S_OK.
667  *   Failure: E_FAIL.
668  *
669  * NOTES
670  *   FileList is a colon-separated list of filenames.  If FileList is
671  *   non-NULL, only the files in the list will be extracted from the
672  *   cab file, otherwise all files will be extracted.  Any number of
673  *   spaces, tabs, or colons can be before or after the list, but
674  *   the list itself must only be separated by colons.
675  */
676 HRESULT WINAPI ExtractFilesA(LPCSTR CabName, LPCSTR ExpandDir, DWORD Flags,
677                              LPCSTR FileList, LPVOID LReserved, DWORD Reserved)
678 {   
679     SESSION session;
680     HMODULE hCabinet;
681     HRESULT res = S_OK;
682     DWORD dwFileCount = 0;
683     DWORD dwFilesFound = 0;
684     LPSTR szConvertedList = NULL;
685
686     TRACE("(%s, %s, %d, %s, %p, %d)\n", debugstr_a(CabName), debugstr_a(ExpandDir),
687           Flags, debugstr_a(FileList), LReserved, Reserved);
688
689     if (!CabName || !ExpandDir)
690         return E_INVALIDARG;
691
692     if (GetFileAttributesA(ExpandDir) == INVALID_FILE_ATTRIBUTES)
693         return HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND);
694
695     hCabinet = LoadLibraryA("cabinet.dll");
696     if (!hCabinet)
697         return E_FAIL;
698
699     pExtract = (void *)GetProcAddress(hCabinet, "Extract");
700     if (!pExtract)
701     {
702         res = E_FAIL;
703         goto done;
704     }
705
706     ZeroMemory(&session, sizeof(SESSION));
707     lstrcpyA(session.Destination, ExpandDir);
708
709     if (FileList)
710     {
711         szConvertedList = convert_file_list(FileList, &dwFileCount);
712         if (!szConvertedList)
713         {
714             res = E_FAIL;
715             goto done;
716         }
717
718         dwFilesFound = fill_file_list(&session, CabName, szConvertedList);
719         if (dwFilesFound != dwFileCount)
720         {
721             res = E_FAIL;
722             goto done;
723         }
724     }
725     else
726         session.Operation |= EXTRACT_FILLFILELIST;
727
728     session.Operation |= EXTRACT_EXTRACTFILES;
729     res = pExtract(&session, CabName);
730
731     if (session.FileList)
732     {
733         struct FILELIST *curr = session.FileList;
734         struct FILELIST *next;
735
736         while (curr)
737         {
738             next = curr->next;
739             free_file_node(curr);
740             curr = next;
741         }
742     }
743
744 done:
745     FreeLibrary(hCabinet);
746     HeapFree(GetProcessHeap(), 0, szConvertedList);
747
748     return res;
749 }
750
751 /***********************************************************************
752  *             ExtractFilesW    (ADVPACK.@)
753  *
754  * Extracts the specified files from a cab archive into
755  * a destination directory.
756  *
757  * PARAMS
758  *   CabName   [I] Filename of the cab archive.
759  *   ExpandDir [I] Destination directory for the extracted files.
760  *   Flags     [I] Reserved.
761  *   FileList  [I] Optional list of files to extract.  See NOTES.
762  *   LReserved [I] Reserved.  Must be NULL.
763  *   Reserved  [I] Reserved.  Must be 0.
764  *
765  * RETURNS
766  *   Success: S_OK.
767  *   Failure: E_FAIL.
768  *
769  * NOTES
770  *   FileList is a colon-separated list of filenames.  If FileList is
771  *   non-NULL, only the files in the list will be extracted from the
772  *   cab file, otherwise all files will be extracted.  Any number of
773  *   spaces, tabs, or colons can be before or after the list, but
774  *   the list itself must only be separated by colons.
775  *
776  * BUGS
777  *   Unimplemented.
778  */
779 HRESULT WINAPI ExtractFilesW(LPCWSTR CabName, LPCWSTR ExpandDir, DWORD Flags,
780                              LPCWSTR FileList, LPVOID LReserved, DWORD Reserved)
781 {
782
783     FIXME("(%s, %s, %d, %s, %p, %d) stub!\n", debugstr_w(CabName), debugstr_w(ExpandDir),
784           Flags, debugstr_w(FileList), LReserved, Reserved);
785
786     return E_FAIL;
787 }
788
789 /***********************************************************************
790  *      FileSaveMarkNotExistA (ADVPACK.@)
791  *
792  * See FileSaveMarkNotExistW.
793  */
794 HRESULT WINAPI FileSaveMarkNotExistA(LPSTR pszFileList, LPSTR pszDir, LPSTR pszBaseName)
795 {
796     TRACE("(%s, %s, %s)\n", debugstr_a(pszFileList),
797           debugstr_a(pszDir), debugstr_a(pszBaseName));
798
799     return AddDelBackupEntryA(pszFileList, pszDir, pszBaseName, AADBE_DEL_ENTRY);
800 }
801
802 /***********************************************************************
803  *      FileSaveMarkNotExistW (ADVPACK.@)
804  *
805  * Marks the files in the file list as not existing so they won't be
806  * backed up during a save.
807  *
808  * PARAMS
809  *   pszFileList [I] NULL-separated list of filenames.
810  *   pszDir      [I] Path of the backup directory.
811  *   pszBaseName [I] Basename of the INI file.
812  *
813  * RETURNS
814  *   Success: S_OK.
815  *   Failure: E_FAIL.
816  */
817 HRESULT WINAPI FileSaveMarkNotExistW(LPWSTR pszFileList, LPWSTR pszDir, LPWSTR pszBaseName)
818 {
819     TRACE("(%s, %s, %s)\n", debugstr_w(pszFileList),
820           debugstr_w(pszDir), debugstr_w(pszBaseName));
821
822     return AddDelBackupEntryW(pszFileList, pszDir, pszBaseName, AADBE_DEL_ENTRY);
823 }
824
825 /***********************************************************************
826  *      FileSaveRestoreA (ADVPACK.@)
827  *
828  * See FileSaveRestoreW.
829  */
830 HRESULT WINAPI FileSaveRestoreA(HWND hDlg, LPSTR pszFileList, LPSTR pszDir,
831                                 LPSTR pszBaseName, DWORD dwFlags)
832 {
833     UNICODE_STRING filelist, dir, basename;
834     HRESULT hr;
835
836     TRACE("(%p, %s, %s, %s, %d)\n", hDlg, debugstr_a(pszFileList),
837           debugstr_a(pszDir), debugstr_a(pszBaseName), dwFlags);
838
839     RtlCreateUnicodeStringFromAsciiz(&filelist, pszFileList);
840     RtlCreateUnicodeStringFromAsciiz(&dir, pszDir);
841     RtlCreateUnicodeStringFromAsciiz(&basename, pszBaseName);
842
843     hr = FileSaveRestoreW(hDlg, filelist.Buffer, dir.Buffer,
844                           basename.Buffer, dwFlags);
845
846     RtlFreeUnicodeString(&filelist);
847     RtlFreeUnicodeString(&dir);
848     RtlFreeUnicodeString(&basename);
849
850     return hr;
851 }                         
852
853 /***********************************************************************
854  *      FileSaveRestoreW (ADVPACK.@)
855  *
856  * Saves or restores the files in the specified file list.
857  *
858  * PARAMS
859  *   hDlg        [I] Handle to the dialog used for the display.
860  *   pszFileList [I] NULL-separated list of filenames.
861  *   pszDir      [I] Path of the backup directory.
862  *   pszBaseName [I] Basename of the backup files.
863  *   dwFlags     [I] See advpub.h.
864  *
865  * RETURNS
866  *   Success: S_OK.
867  *   Failure: E_FAIL.
868  *
869  * NOTES
870  *   If pszFileList is NULL on restore, all files will be restored.
871  *
872  * BUGS
873  *   Unimplemented.
874  */
875 HRESULT WINAPI FileSaveRestoreW(HWND hDlg, LPWSTR pszFileList, LPWSTR pszDir,
876                                 LPWSTR pszBaseName, DWORD dwFlags)
877 {
878     FIXME("(%p, %s, %s, %s, %d) stub\n", hDlg, debugstr_w(pszFileList),
879           debugstr_w(pszDir), debugstr_w(pszBaseName), dwFlags);
880
881     return E_FAIL;
882 }
883
884 /***********************************************************************
885  *      FileSaveRestoreOnINFA (ADVPACK.@)
886  *
887  * See FileSaveRestoreOnINFW.
888  */
889 HRESULT WINAPI FileSaveRestoreOnINFA(HWND hWnd, LPCSTR pszTitle, LPCSTR pszINF,
890                                     LPCSTR pszSection, LPCSTR pszBackupDir,
891                                     LPCSTR pszBaseBackupFile, DWORD dwFlags)
892 {
893     UNICODE_STRING title, inf, section;
894     UNICODE_STRING backupdir, backupfile;
895     HRESULT hr;
896
897     TRACE("(%p, %s, %s, %s, %s, %s, %d)\n", hWnd, debugstr_a(pszTitle),
898           debugstr_a(pszINF), debugstr_a(pszSection), debugstr_a(pszBackupDir),
899           debugstr_a(pszBaseBackupFile), dwFlags);
900
901     RtlCreateUnicodeStringFromAsciiz(&title, pszTitle);
902     RtlCreateUnicodeStringFromAsciiz(&inf, pszINF);
903     RtlCreateUnicodeStringFromAsciiz(&section, pszSection);
904     RtlCreateUnicodeStringFromAsciiz(&backupdir, pszBackupDir);
905     RtlCreateUnicodeStringFromAsciiz(&backupfile, pszBaseBackupFile);
906
907     hr = FileSaveRestoreOnINFW(hWnd, title.Buffer, inf.Buffer, section.Buffer,
908                                backupdir.Buffer, backupfile.Buffer, dwFlags);
909
910     RtlFreeUnicodeString(&title);
911     RtlFreeUnicodeString(&inf);
912     RtlFreeUnicodeString(&section);
913     RtlFreeUnicodeString(&backupdir);
914     RtlFreeUnicodeString(&backupfile);
915
916     return hr;
917 }
918
919 /***********************************************************************
920  *      FileSaveRestoreOnINFW (ADVPACK.@)
921  *
922  *
923  * PARAMS
924  *   hWnd              [I] Handle to the window used for the display.
925  *   pszTitle          [I] Title of the window.
926  *   pszINF            [I] Fully-qualified INF filename.
927  *   pszSection        [I] GenInstall INF section name.
928  *   pszBackupDir      [I] Directory to store the backup file.
929  *   pszBaseBackupFile [I] Basename of the backup files.
930  *   dwFlags           [I] See advpub.h
931  *
932  * RETURNS
933  *   Success: S_OK.
934  *   Failure: E_FAIL.
935  *
936  * NOTES
937  *   If pszSection is NULL, the default section will be used.
938  *
939  * BUGS
940  *   Unimplemented.
941  */
942 HRESULT WINAPI FileSaveRestoreOnINFW(HWND hWnd, LPCWSTR pszTitle, LPCWSTR pszINF,
943                                      LPCWSTR pszSection, LPCWSTR pszBackupDir,
944                                      LPCWSTR pszBaseBackupFile, DWORD dwFlags)
945 {
946     FIXME("(%p, %s, %s, %s, %s, %s, %d): stub\n", hWnd, debugstr_w(pszTitle),
947           debugstr_w(pszINF), debugstr_w(pszSection), debugstr_w(pszBackupDir),
948           debugstr_w(pszBaseBackupFile), dwFlags);
949
950     return E_FAIL;
951 }
952
953 /***********************************************************************
954  *             GetVersionFromFileA     (ADVPACK.@)
955  *
956  * See GetVersionFromFileExW.
957  */
958 HRESULT WINAPI GetVersionFromFileA(LPCSTR Filename, LPDWORD MajorVer,
959                                    LPDWORD MinorVer, BOOL Version )
960 {
961     TRACE("(%s, %p, %p, %d)\n", debugstr_a(Filename), MajorVer, MinorVer, Version);
962     return GetVersionFromFileExA(Filename, MajorVer, MinorVer, Version);
963 }
964
965 /***********************************************************************
966  *             GetVersionFromFileW     (ADVPACK.@)
967  *
968  * See GetVersionFromFileExW.
969  */
970 HRESULT WINAPI GetVersionFromFileW(LPCWSTR Filename, LPDWORD MajorVer,
971                                    LPDWORD MinorVer, BOOL Version )
972 {
973     TRACE("(%s, %p, %p, %d)\n", debugstr_w(Filename), MajorVer, MinorVer, Version);
974     return GetVersionFromFileExW(Filename, MajorVer, MinorVer, Version);
975 }
976
977 /* data for GetVersionFromFileEx */
978 typedef struct tagLANGANDCODEPAGE
979 {
980     WORD wLanguage;
981     WORD wCodePage;
982 } LANGANDCODEPAGE;
983
984 /***********************************************************************
985  *             GetVersionFromFileExA   (ADVPACK.@)
986  *
987  * See GetVersionFromFileExW.
988  */
989 HRESULT WINAPI GetVersionFromFileExA(LPCSTR lpszFilename, LPDWORD pdwMSVer,
990                                      LPDWORD pdwLSVer, BOOL bVersion )
991 {
992     UNICODE_STRING filename;
993     HRESULT res;
994
995     TRACE("(%s, %p, %p, %d)\n", debugstr_a(lpszFilename),
996           pdwMSVer, pdwLSVer, bVersion);
997
998     RtlCreateUnicodeStringFromAsciiz(&filename, lpszFilename);
999
1000     res = GetVersionFromFileExW(filename.Buffer, pdwMSVer, pdwLSVer, bVersion);
1001
1002     RtlFreeUnicodeString(&filename);
1003
1004     return res;
1005 }
1006
1007 /***********************************************************************
1008  *             GetVersionFromFileExW   (ADVPACK.@)
1009  *
1010  * Gets the files version or language information.
1011  *
1012  * PARAMS
1013  *   lpszFilename [I] The file to get the info from.
1014  *   pdwMSVer     [O] Major version.
1015  *   pdwLSVer     [O] Minor version.
1016  *   bVersion     [I] Whether to retrieve version or language info.
1017  *
1018  * RETURNS
1019  *   Always returns S_OK.
1020  *
1021  * NOTES
1022  *   If bVersion is TRUE, version information is retrieved, else
1023  *   pdwMSVer gets the language ID and pdwLSVer gets the codepage ID.
1024  */
1025 HRESULT WINAPI GetVersionFromFileExW(LPCWSTR lpszFilename, LPDWORD pdwMSVer,
1026                                      LPDWORD pdwLSVer, BOOL bVersion )
1027 {
1028     VS_FIXEDFILEINFO *pFixedVersionInfo;
1029     LANGANDCODEPAGE *pLangAndCodePage;
1030     DWORD dwHandle, dwInfoSize;
1031     WCHAR szWinDir[MAX_PATH];
1032     WCHAR szFile[MAX_PATH];
1033     LPVOID pVersionInfo = NULL;
1034     BOOL bFileCopied = FALSE;
1035     UINT uValueLen;
1036
1037     static const WCHAR backslash[] = {'\\',0};
1038     static const WCHAR translation[] = {
1039         '\\','V','a','r','F','i','l','e','I','n','f','o',
1040         '\\','T','r','a','n','s','l','a','t','i','o','n',0
1041     };
1042
1043     TRACE("(%s, %p, %p, %d)\n", debugstr_w(lpszFilename),
1044           pdwMSVer, pdwLSVer, bVersion);
1045
1046     *pdwLSVer = 0;
1047     *pdwMSVer = 0;
1048
1049     lstrcpynW(szFile, lpszFilename, MAX_PATH);
1050
1051     dwInfoSize = GetFileVersionInfoSizeW(szFile, &dwHandle);
1052     if (!dwInfoSize)
1053     {
1054         /* check that the file exists */
1055         if (GetFileAttributesW(szFile) == INVALID_FILE_ATTRIBUTES)
1056             return S_OK;
1057
1058         /* file exists, but won't be found by GetFileVersionInfoSize,
1059         * so copy it to the temp dir where it will be found.
1060         */
1061         GetWindowsDirectoryW(szWinDir, MAX_PATH);
1062         GetTempFileNameW(szWinDir, NULL, 0, szFile);
1063         CopyFileW(lpszFilename, szFile, FALSE);
1064         bFileCopied = TRUE;
1065
1066         dwInfoSize = GetFileVersionInfoSizeW(szFile, &dwHandle);
1067         if (!dwInfoSize)
1068             goto done;
1069     }
1070
1071     pVersionInfo = HeapAlloc(GetProcessHeap(), 0, dwInfoSize);
1072     if (!pVersionInfo)
1073         goto done;
1074
1075     if (!GetFileVersionInfoW(szFile, dwHandle, dwInfoSize, pVersionInfo))
1076         goto done;
1077
1078     if (bVersion)
1079     {
1080         if (!VerQueryValueW(pVersionInfo, backslash,
1081             (LPVOID *)&pFixedVersionInfo, &uValueLen))
1082             goto done;
1083
1084         if (!uValueLen)
1085             goto done;
1086
1087         *pdwMSVer = pFixedVersionInfo->dwFileVersionMS;
1088         *pdwLSVer = pFixedVersionInfo->dwFileVersionLS;
1089     }
1090     else
1091     {
1092         if (!VerQueryValueW(pVersionInfo, translation,
1093              (LPVOID *)&pLangAndCodePage, &uValueLen))
1094             goto done;
1095
1096         if (!uValueLen)
1097             goto done;
1098
1099         *pdwMSVer = pLangAndCodePage->wLanguage;
1100         *pdwLSVer = pLangAndCodePage->wCodePage;
1101     }
1102
1103 done:
1104     HeapFree(GetProcessHeap(), 0, pVersionInfo);
1105
1106     if (bFileCopied)
1107         DeleteFileW(szFile);
1108
1109     return S_OK;
1110 }