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',',','',',','',',','',',','',',','',',','-','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(¶ms, cmdline);
467
468 hr = DelNodeRunDLL32W(hWnd, hInst, params.Buffer, show);
469
470 RtlFreeUnicodeString(¶ms);
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 * FileSaveMarkNotExistA (ADVPACK.@)
753 *
754 * See FileSaveMarkNotExistW.
755 */
756 HRESULT WINAPI FileSaveMarkNotExistA(LPSTR pszFileList, LPSTR pszDir, LPSTR pszBaseName)
757 {
758 TRACE("(%s, %s, %s)\n", debugstr_a(pszFileList),
759 debugstr_a(pszDir), debugstr_a(pszBaseName));
760
761 return AddDelBackupEntryA(pszFileList, pszDir, pszBaseName, AADBE_DEL_ENTRY);
762 }
763
764 /***********************************************************************
765 * FileSaveMarkNotExistW (ADVPACK.@)
766 *
767 * Marks the files in the file list as not existing so they won't be
768 * backed up during a save.
769 *
770 * PARAMS
771 * pszFileList [I] NULL-separated list of filenames.
772 * pszDir [I] Path of the backup directory.
773 * pszBaseName [I] Basename of the INI file.
774 *
775 * RETURNS
776 * Success: S_OK.
777 * Failure: E_FAIL.
778 */
779 HRESULT WINAPI FileSaveMarkNotExistW(LPWSTR pszFileList, LPWSTR pszDir, LPWSTR pszBaseName)
780 {
781 TRACE("(%s, %s, %s)\n", debugstr_w(pszFileList),
782 debugstr_w(pszDir), debugstr_w(pszBaseName));
783
784 return AddDelBackupEntryW(pszFileList, pszDir, pszBaseName, AADBE_DEL_ENTRY);
785 }
786
787 /***********************************************************************
788 * FileSaveRestoreA (ADVPACK.@)
789 *
790 * See FileSaveRestoreW.
791 */
792 HRESULT WINAPI FileSaveRestoreA(HWND hDlg, LPSTR pszFileList, LPSTR pszDir,
793 LPSTR pszBaseName, DWORD dwFlags)
794 {
795 UNICODE_STRING filelist, dir, basename;
796 HRESULT hr;
797
798 TRACE("(%p, %s, %s, %s, %d)\n", hDlg, debugstr_a(pszFileList),
799 debugstr_a(pszDir), debugstr_a(pszBaseName), dwFlags);
800
801 RtlCreateUnicodeStringFromAsciiz(&filelist, pszFileList);
802 RtlCreateUnicodeStringFromAsciiz(&dir, pszDir);
803 RtlCreateUnicodeStringFromAsciiz(&basename, pszBaseName);
804
805 hr = FileSaveRestoreW(hDlg, filelist.Buffer, dir.Buffer,
806 basename.Buffer, dwFlags);
807
808 RtlFreeUnicodeString(&filelist);
809 RtlFreeUnicodeString(&dir);
810 RtlFreeUnicodeString(&basename);
811
812 return hr;
813 }
814
815 /***********************************************************************
816 * FileSaveRestoreW (ADVPACK.@)
817 *
818 * Saves or restores the files in the specified file list.
819 *
820 * PARAMS
821 * hDlg [I] Handle to the dialog used for the display.
822 * pszFileList [I] NULL-separated list of filenames.
823 * pszDir [I] Path of the backup directory.
824 * pszBaseName [I] Basename of the backup files.
825 * dwFlags [I] See advpub.h.
826 *
827 * RETURNS
828 * Success: S_OK.
829 * Failure: E_FAIL.
830 *
831 * NOTES
832 * If pszFileList is NULL on restore, all files will be restored.
833 *
834 * BUGS
835 * Unimplemented.
836 */
837 HRESULT WINAPI FileSaveRestoreW(HWND hDlg, LPWSTR pszFileList, LPWSTR pszDir,
838 LPWSTR pszBaseName, DWORD dwFlags)
839 {
840 FIXME("(%p, %s, %s, %s, %d) stub\n", hDlg, debugstr_w(pszFileList),
841 debugstr_w(pszDir), debugstr_w(pszBaseName), dwFlags);
842
843 return E_FAIL;
844 }
845
846 /***********************************************************************
847 * FileSaveRestoreOnINFA (ADVPACK.@)
848 *
849 * See FileSaveRestoreOnINFW.
850 */
851 HRESULT WINAPI FileSaveRestoreOnINFA(HWND hWnd, LPCSTR pszTitle, LPCSTR pszINF,
852 LPCSTR pszSection, LPCSTR pszBackupDir,
853 LPCSTR pszBaseBackupFile, DWORD dwFlags)
854 {
855 UNICODE_STRING title, inf, section;
856 UNICODE_STRING backupdir, backupfile;
857 HRESULT hr;
858
859 TRACE("(%p, %s, %s, %s, %s, %s, %d)\n", hWnd, debugstr_a(pszTitle),
860 debugstr_a(pszINF), debugstr_a(pszSection), debugstr_a(pszBackupDir),
861 debugstr_a(pszBaseBackupFile), dwFlags);
862
863 RtlCreateUnicodeStringFromAsciiz(&title, pszTitle);
864 RtlCreateUnicodeStringFromAsciiz(&inf, pszINF);
865 RtlCreateUnicodeStringFromAsciiz(§ion, pszSection);
866 RtlCreateUnicodeStringFromAsciiz(&backupdir, pszBackupDir);
867 RtlCreateUnicodeStringFromAsciiz(&backupfile, pszBaseBackupFile);
868
869 hr = FileSaveRestoreOnINFW(hWnd, title.Buffer, inf.Buffer, section.Buffer,
870 backupdir.Buffer, backupfile.Buffer, dwFlags);
871
872 RtlFreeUnicodeString(&title);
873 RtlFreeUnicodeString(&inf);
874 RtlFreeUnicodeString(§ion);
875 RtlFreeUnicodeString(&backupdir);
876 RtlFreeUnicodeString(&backupfile);
877
878 return hr;
879 }
880
881 /***********************************************************************
882 * FileSaveRestoreOnINFW (ADVPACK.@)
883 *
884 *
885 * PARAMS
886 * hWnd [I] Handle to the window used for the display.
887 * pszTitle [I] Title of the window.
888 * pszINF [I] Fully-qualified INF filename.
889 * pszSection [I] GenInstall INF section name.
890 * pszBackupDir [I] Directory to store the backup file.
891 * pszBaseBackupFile [I] Basename of the backup files.
892 * dwFlags [I] See advpub.h
893 *
894 * RETURNS
895 * Success: S_OK.
896 * Failure: E_FAIL.
897 *
898 * NOTES
899 * If pszSection is NULL, the default section will be used.
900 *
901 * BUGS
902 * Unimplemented.
903 */
904 HRESULT WINAPI FileSaveRestoreOnINFW(HWND hWnd, LPCWSTR pszTitle, LPCWSTR pszINF,
905 LPCWSTR pszSection, LPCWSTR pszBackupDir,
906 LPCWSTR pszBaseBackupFile, DWORD dwFlags)
907 {
908 FIXME("(%p, %s, %s, %s, %s, %s, %d): stub\n", hWnd, debugstr_w(pszTitle),
909 debugstr_w(pszINF), debugstr_w(pszSection), debugstr_w(pszBackupDir),
910 debugstr_w(pszBaseBackupFile), dwFlags);
911
912 return E_FAIL;
913 }
914
915 /***********************************************************************
916 * GetVersionFromFileA (ADVPACK.@)
917 *
918 * See GetVersionFromFileExW.
919 */
920 HRESULT WINAPI GetVersionFromFileA(LPCSTR Filename, LPDWORD MajorVer,
921 LPDWORD MinorVer, BOOL Version )
922 {
923 TRACE("(%s, %p, %p, %d)\n", debugstr_a(Filename), MajorVer, MinorVer, Version);
924 return GetVersionFromFileExA(Filename, MajorVer, MinorVer, Version);
925 }
926
927 /***********************************************************************
928 * GetVersionFromFileW (ADVPACK.@)
929 *
930 * See GetVersionFromFileExW.
931 */
932 HRESULT WINAPI GetVersionFromFileW(LPCWSTR Filename, LPDWORD MajorVer,
933 LPDWORD MinorVer, BOOL Version )
934 {
935 TRACE("(%s, %p, %p, %d)\n", debugstr_w(Filename), MajorVer, MinorVer, Version);
936 return GetVersionFromFileExW(Filename, MajorVer, MinorVer, Version);
937 }
938
939 /* data for GetVersionFromFileEx */
940 typedef struct tagLANGANDCODEPAGE
941 {
942 WORD wLanguage;
943 WORD wCodePage;
944 } LANGANDCODEPAGE;
945
946 /***********************************************************************
947 * GetVersionFromFileExA (ADVPACK.@)
948 *
949 * See GetVersionFromFileExW.
950 */
951 HRESULT WINAPI GetVersionFromFileExA(LPCSTR lpszFilename, LPDWORD pdwMSVer,
952 LPDWORD pdwLSVer, BOOL bVersion )
953 {
954 UNICODE_STRING filename;
955 HRESULT res;
956
957 TRACE("(%s, %p, %p, %d)\n", debugstr_a(lpszFilename),
958 pdwMSVer, pdwLSVer, bVersion);
959
960 RtlCreateUnicodeStringFromAsciiz(&filename, lpszFilename);
961
962 res = GetVersionFromFileExW(filename.Buffer, pdwMSVer, pdwLSVer, bVersion);
963
964 RtlFreeUnicodeString(&filename);
965
966 return res;
967 }
968
969 /***********************************************************************
970 * GetVersionFromFileExW (ADVPACK.@)
971 *
972 * Gets the files version or language information.
973 *
974 * PARAMS
975 * lpszFilename [I] The file to get the info from.
976 * pdwMSVer [O] Major version.
977 * pdwLSVer [O] Minor version.
978 * bVersion [I] Whether to retrieve version or language info.
979 *
980 * RETURNS
981 * Always returns S_OK.
982 *
983 * NOTES
984 * If bVersion is TRUE, version information is retrieved, else
985 * pdwMSVer gets the language ID and pdwLSVer gets the codepage ID.
986 */
987 HRESULT WINAPI GetVersionFromFileExW(LPCWSTR lpszFilename, LPDWORD pdwMSVer,
988 LPDWORD pdwLSVer, BOOL bVersion )
989 {
990 VS_FIXEDFILEINFO *pFixedVersionInfo;
991 LANGANDCODEPAGE *pLangAndCodePage;
992 DWORD dwHandle, dwInfoSize;
993 WCHAR szWinDir[MAX_PATH];
994 WCHAR szFile[MAX_PATH];
995 LPVOID pVersionInfo = NULL;
996 BOOL bFileCopied = FALSE;
997 UINT uValueLen;
998
999 static const WCHAR backslash[] = {'\\',0};
1000 static const WCHAR translation[] = {
1001 '\\','V','a','r','F','i','l','e','I','n','f','o',
1002 '\\','T','r','a','n','s','l','a','t','i','o','n',0
1003 };
1004
1005 TRACE("(%s, %p, %p, %d)\n", debugstr_w(lpszFilename),
1006 pdwMSVer, pdwLSVer, bVersion);
1007
1008 *pdwLSVer = 0;
1009 *pdwMSVer = 0;
1010
1011 lstrcpynW(szFile, lpszFilename, MAX_PATH);
1012
1013 dwInfoSize = GetFileVersionInfoSizeW(szFile, &dwHandle);
1014 if (!dwInfoSize)
1015 {
1016 /* check that the file exists */
1017 if (GetFileAttributesW(szFile) == INVALID_FILE_ATTRIBUTES)
1018 return S_OK;
1019
1020 /* file exists, but won't be found by GetFileVersionInfoSize,
1021 * so copy it to the temp dir where it will be found.
1022 */
1023 GetWindowsDirectoryW(szWinDir, MAX_PATH);
1024 GetTempFileNameW(szWinDir, NULL, 0, szFile);
1025 CopyFileW(lpszFilename, szFile, FALSE);
1026 bFileCopied = TRUE;
1027
1028 dwInfoSize = GetFileVersionInfoSizeW(szFile, &dwHandle);
1029 if (!dwInfoSize)
1030 goto done;
1031 }
1032
1033 pVersionInfo = HeapAlloc(GetProcessHeap(), 0, dwInfoSize);
1034 if (!pVersionInfo)
1035 goto done;
1036
1037 if (!GetFileVersionInfoW(szFile, dwHandle, dwInfoSize, pVersionInfo))
1038 goto done;
1039
1040 if (bVersion)
1041 {
1042 if (!VerQueryValueW(pVersionInfo, backslash,
1043 (LPVOID *)&pFixedVersionInfo, &uValueLen))
1044 goto done;
1045
1046 if (!uValueLen)
1047 goto done;
1048
1049 *pdwMSVer = pFixedVersionInfo->dwFileVersionMS;
1050 *pdwLSVer = pFixedVersionInfo->dwFileVersionLS;
1051 }
1052 else
1053 {
1054 if (!VerQueryValueW(pVersionInfo, translation,
1055 (LPVOID *)&pLangAndCodePage, &uValueLen))
1056 goto done;
1057
1058 if (!uValueLen)
1059 goto done;
1060
1061 *pdwMSVer = pLangAndCodePage->wLanguage;
1062 *pdwLSVer = pLangAndCodePage->wCodePage;
1063 }
1064
1065 done:
1066 HeapFree(GetProcessHeap(), 0, pVersionInfo);
1067
1068 if (bFileCopied)
1069 DeleteFileW(szFile);
1070
1071 return S_OK;
1072 }
1073
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.