ReactOS  0.4.13-dev-52-g0efcfec
files.c
Go to the documentation of this file.
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 
38 
39 /* converts an ansi double null-terminated list to a unicode 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;
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);
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);
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 
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 */
162 
163  return S_OK;
164 }
165 
166 /* FIXME: this is only for the local case, X:\ */
167 #define ROOT_LENGTH 3
168 
170  UINT_PTR Param1, UINT_PTR Param2)
171 {
172  return 1;
173 }
174 
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,
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,
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)
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+1) * sizeof(WCHAR));
283  lstrcpyW(szDestFilename, lpszDestFile);
284  }
285  else
286  {
287  dwLen = lstrlenW(lpszSourceFile);
288  szDestFilename = HeapAlloc(GetProcessHeap(), 0, (dwLen+1) * 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 
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:
323  SetupCloseFileQueue(fileQueue);
324 
325  HeapFree(GetProcessHeap(), 0, szDestFilename);
326 
327  return HRESULT_FROM_WIN32(dwLastError);
328 }
329 
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));
376  {
377  ret = S_OK;
378  }
379  }
380  }
381  else
382  {
383  TRACE("%s: file\n", debugstr_w(fname));
385  {
386  ret = S_OK;
387  }
388  }
389 
390  return ret;
391 }
392 
393 /***********************************************************************
394  * DelNodeA (ADVPACK.@)
395  *
396  * See DelNodeW.
397  */
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  */
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 
449  }
450 
451  return ret;
452 }
453 
454 /***********************************************************************
455  * DelNodeRunDLL32A (ADVPACK.@)
456  *
457  * See DelNodeRunDLL32W.
458  */
460 {
462  HRESULT hr;
463 
464  TRACE("(%p, %p, %s, %i)\n", hWnd, hInst, debugstr_a(cmdline), show);
465 
467 
468  hr = DelNodeRunDLL32W(hWnd, hInst, params.Buffer, show);
469 
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  */
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, ',', TRUE);
505  szFlags = get_parameter(&cmdline_ptr, ',', TRUE);
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{
525  struct FILELIST *next;
527 };
528 
529 typedef struct {
536  CHAR CurrentFile[MAX_PATH];
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  */
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 (!szConvertedList[0])
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 static void free_file_list(SESSION* session)
652 {
653  struct FILELIST *next, *curr = session->FileList;
654 
655  while (curr)
656  {
657  next = curr->next;
658  free_file_node(curr);
659  curr = next;
660  }
661 }
662 
663 /***********************************************************************
664  * ExtractFilesA (ADVPACK.@)
665  *
666  * Extracts the specified files from a cab archive into
667  * a destination directory.
668  *
669  * PARAMS
670  * CabName [I] Filename of the cab archive.
671  * ExpandDir [I] Destination directory for the extracted files.
672  * Flags [I] Reserved.
673  * FileList [I] Optional list of files to extract. See NOTES.
674  * LReserved [I] Reserved. Must be NULL.
675  * Reserved [I] Reserved. Must be 0.
676  *
677  * RETURNS
678  * Success: S_OK.
679  * Failure: E_FAIL.
680  *
681  * NOTES
682  * FileList is a colon-separated list of filenames. If FileList is
683  * non-NULL, only the files in the list will be extracted from the
684  * cab file, otherwise all files will be extracted. Any number of
685  * spaces, tabs, or colons can be before or after the list, but
686  * the list itself must only be separated by colons.
687  */
689  LPCSTR FileList, LPVOID LReserved, DWORD Reserved)
690 {
691  SESSION session;
693  HRESULT res = S_OK;
694  DWORD dwFileCount = 0;
695  DWORD dwFilesFound = 0;
696  LPSTR szConvertedList = NULL;
697 
698  TRACE("(%s, %s, %d, %s, %p, %d)\n", debugstr_a(CabName), debugstr_a(ExpandDir),
699  Flags, debugstr_a(FileList), LReserved, Reserved);
700 
701  if (!CabName || !ExpandDir)
702  return E_INVALIDARG;
703 
706 
707  hCabinet = LoadLibraryA("cabinet.dll");
708  if (!hCabinet)
709  return E_FAIL;
710 
711  ZeroMemory(&session, sizeof(SESSION));
712 
713  pExtract = (void *)GetProcAddress(hCabinet, "Extract");
714  if (!pExtract)
715  {
716  res = E_FAIL;
717  goto done;
718  }
719 
720  lstrcpyA(session.Destination, ExpandDir);
721 
722  if (FileList)
723  {
724  szConvertedList = convert_file_list(FileList, &dwFileCount);
725  if (!szConvertedList)
726  {
727  res = E_FAIL;
728  goto done;
729  }
730 
731  dwFilesFound = fill_file_list(&session, CabName, szConvertedList);
732  if (dwFilesFound != dwFileCount)
733  {
734  res = E_FAIL;
735  goto done;
736  }
737  }
738  else
739  session.Operation |= EXTRACT_FILLFILELIST;
740 
741  session.Operation |= EXTRACT_EXTRACTFILES;
742  res = pExtract(&session, CabName);
743 
744 done:
745  free_file_list(&session);
747  HeapFree(GetProcessHeap(), 0, szConvertedList);
748 
749  return res;
750 }
751 
752 /***********************************************************************
753  * ExtractFilesW (ADVPACK.@)
754  *
755  * Extracts the specified files from a cab archive into
756  * a destination directory.
757  *
758  * PARAMS
759  * CabName [I] Filename of the cab archive.
760  * ExpandDir [I] Destination directory for the extracted files.
761  * Flags [I] Reserved.
762  * FileList [I] Optional list of files to extract. See NOTES.
763  * LReserved [I] Reserved. Must be NULL.
764  * Reserved [I] Reserved. Must be 0.
765  *
766  * RETURNS
767  * Success: S_OK.
768  * Failure: E_FAIL.
769  *
770  * NOTES
771  * FileList is a colon-separated list of filenames. If FileList is
772  * non-NULL, only the files in the list will be extracted from the
773  * cab file, otherwise all files will be extracted. Any number of
774  * spaces, tabs, or colons can be before or after the list, but
775  * the list itself must only be separated by colons.
776  *
777  * BUGS
778  * Unimplemented.
779  */
781  LPCWSTR FileList, LPVOID LReserved, DWORD Reserved)
782 {
783  char *cab_name = NULL, *expand_dir = NULL, *file_list = NULL;
784  HRESULT hres = S_OK;
785 
786  TRACE("(%s, %s, %d, %s, %p, %d)\n", debugstr_w(CabName), debugstr_w(ExpandDir),
787  Flags, debugstr_w(FileList), LReserved, Reserved);
788 
789  if(CabName) {
790  cab_name = heap_strdupWtoA(CabName);
791  if(!cab_name)
792  return E_OUTOFMEMORY;
793  }
794 
795  if(ExpandDir) {
796  expand_dir = heap_strdupWtoA(ExpandDir);
797  if(!expand_dir)
799  }
800 
801  if(SUCCEEDED(hres) && FileList) {
802  file_list = heap_strdupWtoA(FileList);
803  if(!file_list)
805  }
806 
807  /* cabinet.dll, which does the real job of extracting files, doesn't have UNICODE API,
808  so we need W->A conversion at some point anyway. */
809  if(SUCCEEDED(hres))
810  hres = ExtractFilesA(cab_name, expand_dir, Flags, file_list, LReserved, Reserved);
811 
812  heap_free(cab_name);
813  heap_free(expand_dir);
814  heap_free(file_list);
815  return hres;
816 }
817 
818 /***********************************************************************
819  * FileSaveMarkNotExistA (ADVPACK.@)
820  *
821  * See FileSaveMarkNotExistW.
822  */
824 {
825  TRACE("(%s, %s, %s)\n", debugstr_a(pszFileList),
826  debugstr_a(pszDir), debugstr_a(pszBaseName));
827 
828  return AddDelBackupEntryA(pszFileList, pszDir, pszBaseName, AADBE_DEL_ENTRY);
829 }
830 
831 /***********************************************************************
832  * FileSaveMarkNotExistW (ADVPACK.@)
833  *
834  * Marks the files in the file list as not existing so they won't be
835  * backed up during a save.
836  *
837  * PARAMS
838  * pszFileList [I] NULL-separated list of filenames.
839  * pszDir [I] Path of the backup directory.
840  * pszBaseName [I] Basename of the INI file.
841  *
842  * RETURNS
843  * Success: S_OK.
844  * Failure: E_FAIL.
845  */
847 {
848  TRACE("(%s, %s, %s)\n", debugstr_w(pszFileList),
849  debugstr_w(pszDir), debugstr_w(pszBaseName));
850 
851  return AddDelBackupEntryW(pszFileList, pszDir, pszBaseName, AADBE_DEL_ENTRY);
852 }
853 
854 /***********************************************************************
855  * FileSaveRestoreA (ADVPACK.@)
856  *
857  * See FileSaveRestoreW.
858  */
860  LPSTR pszBaseName, DWORD dwFlags)
861 {
862  UNICODE_STRING filelist, dir, basename;
863  HRESULT hr;
864 
865  TRACE("(%p, %s, %s, %s, %d)\n", hDlg, debugstr_a(pszFileList),
866  debugstr_a(pszDir), debugstr_a(pszBaseName), dwFlags);
867 
868  RtlCreateUnicodeStringFromAsciiz(&filelist, pszFileList);
871 
872  hr = FileSaveRestoreW(hDlg, filelist.Buffer, dir.Buffer,
873  basename.Buffer, dwFlags);
874 
875  RtlFreeUnicodeString(&filelist);
878 
879  return hr;
880 }
881 
882 /***********************************************************************
883  * FileSaveRestoreW (ADVPACK.@)
884  *
885  * Saves or restores the files in the specified file list.
886  *
887  * PARAMS
888  * hDlg [I] Handle to the dialog used for the display.
889  * pszFileList [I] NULL-separated list of filenames.
890  * pszDir [I] Path of the backup directory.
891  * pszBaseName [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 pszFileList is NULL on restore, all files will be restored.
900  *
901  * BUGS
902  * Unimplemented.
903  */
905  LPWSTR pszBaseName, DWORD dwFlags)
906 {
907  FIXME("(%p, %s, %s, %s, %d) stub\n", hDlg, debugstr_w(pszFileList),
908  debugstr_w(pszDir), debugstr_w(pszBaseName), dwFlags);
909 
910  return E_FAIL;
911 }
912 
913 /***********************************************************************
914  * FileSaveRestoreOnINFA (ADVPACK.@)
915  *
916  * See FileSaveRestoreOnINFW.
917  */
919  LPCSTR pszSection, LPCSTR pszBackupDir,
920  LPCSTR pszBaseBackupFile, DWORD dwFlags)
921 {
923  UNICODE_STRING backupdir, backupfile;
924  HRESULT hr;
925 
926  TRACE("(%p, %s, %s, %s, %s, %s, %d)\n", hWnd, debugstr_a(pszTitle),
927  debugstr_a(pszINF), debugstr_a(pszSection), debugstr_a(pszBackupDir),
928  debugstr_a(pszBaseBackupFile), dwFlags);
929 
931  RtlCreateUnicodeStringFromAsciiz(&inf, pszINF);
933  RtlCreateUnicodeStringFromAsciiz(&backupdir, pszBackupDir);
934  RtlCreateUnicodeStringFromAsciiz(&backupfile, pszBaseBackupFile);
935 
936  hr = FileSaveRestoreOnINFW(hWnd, title.Buffer, inf.Buffer, section.Buffer,
937  backupdir.Buffer, backupfile.Buffer, dwFlags);
938 
940  RtlFreeUnicodeString(&inf);
942  RtlFreeUnicodeString(&backupdir);
943  RtlFreeUnicodeString(&backupfile);
944 
945  return hr;
946 }
947 
948 /***********************************************************************
949  * FileSaveRestoreOnINFW (ADVPACK.@)
950  *
951  *
952  * PARAMS
953  * hWnd [I] Handle to the window used for the display.
954  * pszTitle [I] Title of the window.
955  * pszINF [I] Fully-qualified INF filename.
956  * pszSection [I] GenInstall INF section name.
957  * pszBackupDir [I] Directory to store the backup file.
958  * pszBaseBackupFile [I] Basename of the backup files.
959  * dwFlags [I] See advpub.h
960  *
961  * RETURNS
962  * Success: S_OK.
963  * Failure: E_FAIL.
964  *
965  * NOTES
966  * If pszSection is NULL, the default section will be used.
967  *
968  * BUGS
969  * Unimplemented.
970  */
972  LPCWSTR pszSection, LPCWSTR pszBackupDir,
973  LPCWSTR pszBaseBackupFile, DWORD dwFlags)
974 {
975  FIXME("(%p, %s, %s, %s, %s, %s, %d): stub\n", hWnd, debugstr_w(pszTitle),
976  debugstr_w(pszINF), debugstr_w(pszSection), debugstr_w(pszBackupDir),
977  debugstr_w(pszBaseBackupFile), dwFlags);
978 
979  return E_FAIL;
980 }
981 
982 /***********************************************************************
983  * GetVersionFromFileA (ADVPACK.@)
984  *
985  * See GetVersionFromFileExW.
986  */
988  LPDWORD MinorVer, BOOL Version )
989 {
990  TRACE("(%s, %p, %p, %d)\n", debugstr_a(Filename), MajorVer, MinorVer, Version);
991  return GetVersionFromFileExA(Filename, MajorVer, MinorVer, Version);
992 }
993 
994 /***********************************************************************
995  * GetVersionFromFileW (ADVPACK.@)
996  *
997  * See GetVersionFromFileExW.
998  */
1000  LPDWORD MinorVer, BOOL Version )
1001 {
1002  TRACE("(%s, %p, %p, %d)\n", debugstr_w(Filename), MajorVer, MinorVer, Version);
1003  return GetVersionFromFileExW(Filename, MajorVer, MinorVer, Version);
1004 }
1005 
1006 /* data for GetVersionFromFileEx */
1007 typedef struct tagLANGANDCODEPAGE
1008 {
1011 } LANGANDCODEPAGE;
1012 
1013 /***********************************************************************
1014  * GetVersionFromFileExA (ADVPACK.@)
1015  *
1016  * See GetVersionFromFileExW.
1017  */
1019  LPDWORD pdwLSVer, BOOL bVersion )
1020 {
1022  HRESULT res;
1023 
1024  TRACE("(%s, %p, %p, %d)\n", debugstr_a(lpszFilename),
1025  pdwMSVer, pdwLSVer, bVersion);
1026 
1028 
1029  res = GetVersionFromFileExW(filename.Buffer, pdwMSVer, pdwLSVer, bVersion);
1030 
1032 
1033  return res;
1034 }
1035 
1036 /***********************************************************************
1037  * GetVersionFromFileExW (ADVPACK.@)
1038  *
1039  * Gets the files version or language information.
1040  *
1041  * PARAMS
1042  * lpszFilename [I] The file to get the info from.
1043  * pdwMSVer [O] Major version.
1044  * pdwLSVer [O] Minor version.
1045  * bVersion [I] Whether to retrieve version or language info.
1046  *
1047  * RETURNS
1048  * Always returns S_OK.
1049  *
1050  * NOTES
1051  * If bVersion is TRUE, version information is retrieved, else
1052  * pdwMSVer gets the language ID and pdwLSVer gets the codepage ID.
1053  */
1055  LPDWORD pdwLSVer, BOOL bVersion )
1056 {
1057  VS_FIXEDFILEINFO *pFixedVersionInfo;
1058  LANGANDCODEPAGE *pLangAndCodePage;
1059  DWORD dwHandle, dwInfoSize;
1060  WCHAR szWinDir[MAX_PATH];
1061  WCHAR szFile[MAX_PATH];
1062  LPVOID pVersionInfo = NULL;
1063  BOOL bFileCopied = FALSE;
1064  UINT uValueLen;
1065 
1066  static const WCHAR backslash[] = {'\\',0};
1067  static const WCHAR translation[] = {
1068  '\\','V','a','r','F','i','l','e','I','n','f','o',
1069  '\\','T','r','a','n','s','l','a','t','i','o','n',0
1070  };
1071 
1072  TRACE("(%s, %p, %p, %d)\n", debugstr_w(lpszFilename),
1073  pdwMSVer, pdwLSVer, bVersion);
1074 
1075  *pdwLSVer = 0;
1076  *pdwMSVer = 0;
1077 
1078  lstrcpynW(szFile, lpszFilename, MAX_PATH);
1079 
1080  dwInfoSize = GetFileVersionInfoSizeW(szFile, &dwHandle);
1081  if (!dwInfoSize)
1082  {
1083  /* check that the file exists */
1085  return S_OK;
1086 
1087  /* file exists, but won't be found by GetFileVersionInfoSize,
1088  * so copy it to the temp dir where it will be found.
1089  */
1090  GetWindowsDirectoryW(szWinDir, MAX_PATH);
1091  GetTempFileNameW(szWinDir, NULL, 0, szFile);
1092  CopyFileW(lpszFilename, szFile, FALSE);
1093  bFileCopied = TRUE;
1094 
1095  dwInfoSize = GetFileVersionInfoSizeW(szFile, &dwHandle);
1096  if (!dwInfoSize)
1097  goto done;
1098  }
1099 
1100  pVersionInfo = HeapAlloc(GetProcessHeap(), 0, dwInfoSize);
1101  if (!pVersionInfo)
1102  goto done;
1103 
1104  if (!GetFileVersionInfoW(szFile, dwHandle, dwInfoSize, pVersionInfo))
1105  goto done;
1106 
1107  if (bVersion)
1108  {
1109  if (!VerQueryValueW(pVersionInfo, backslash,
1110  (LPVOID *)&pFixedVersionInfo, &uValueLen))
1111  goto done;
1112 
1113  if (!uValueLen)
1114  goto done;
1115 
1116  *pdwMSVer = pFixedVersionInfo->dwFileVersionMS;
1117  *pdwLSVer = pFixedVersionInfo->dwFileVersionLS;
1118  }
1119  else
1120  {
1121  if (!VerQueryValueW(pVersionInfo, translation,
1122  (LPVOID *)&pLangAndCodePage, &uValueLen))
1123  goto done;
1124 
1125  if (!uValueLen)
1126  goto done;
1127 
1128  *pdwMSVer = pLangAndCodePage->wLanguage;
1129  *pdwLSVer = pLangAndCodePage->wCodePage;
1130  }
1131 
1132 done:
1133  HeapFree(GetProcessHeap(), 0, pVersionInfo);
1134 
1135  if (bFileCopied)
1136  DeleteFileW(szFile);
1137 
1138  return S_OK;
1139 }
static DWORD fill_file_list(SESSION *session, LPCSTR szCabName, LPCSTR szFileList)
Definition: files.c:624
BOOL WINAPI SetFileAttributesW(LPCWSTR lpFileName, DWORD dwFileAttributes)
Definition: fileinfo.c:944
HRESULT WINAPI DelNodeA(LPCSTR pszFileOrDirName, DWORD dwFlags)
Definition: files.c:398
BOOL WINAPI FindNextFileW(IN HANDLE hFindFile, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:382
INT FileCount
Definition: files.c:533
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
struct FILELIST * FilterList
Definition: files.c:538
HRESULT WINAPI GetVersionFromFileW(LPCWSTR Filename, LPDWORD MajorVer, LPDWORD MinorVer, BOOL Version)
Definition: files.c:999
static long backup()
Definition: maze.c:403
#define TRUE
Definition: types.h:120
static HRESULT DELNODE_recurse_dirtree(LPWSTR fname, DWORD flags)
Definition: files.c:330
IN PVOID IN PVOID IN USHORT Version
Definition: pci.h:359
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
static void free_file_node(struct FILELIST *pNode)
Definition: files.c:594
#define ERROR_SUCCESS
Definition: deptool.c:10
int WINAPI lstrcmpiA(LPCSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:42
HRESULT hr
Definition: shlfolder.c:183
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define EXTRACT_EXTRACTFILES
Definition: files.c:521
POINT last
Definition: font.c:46
struct FILELIST * FileList
Definition: files.c:532
static void basename(LPCWSTR path, LPWSTR name)
Definition: profile.c:38
#define CP_ACP
Definition: compat.h:99
HRESULT WINAPI DelNodeRunDLL32W(HWND hWnd, HINSTANCE hInst, LPWSTR cmdline, INT show)
Definition: files.c:490
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
static HRESULT(WINAPI *pExtract)(SESSION *
char CHAR
Definition: xmlstorage.h:175
vector< FileInfo > FileList
Definition: DriveVolume.h:63
const GLint * first
Definition: glext.h:5794
HSPFILEQ WINAPI SetupOpenFileQueue(VOID)
Definition: fileqsup.c:161
#define CALLBACK
Definition: compat.h:27
HWND hWnd
Definition: settings.c:17
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define ZeroMemory
Definition: winbase.h:1635
BOOL WINAPI SetupQueueCopyW(HSPFILEQ queue, PCWSTR src_root, PCWSTR src_path, PCWSTR src_file, PCWSTR src_descr, PCWSTR src_tag, PCWSTR dst_dir, PCWSTR dst_file, DWORD style)
Definition: queue.c:622
TCHAR * cmdline
Definition: stretchblt.cpp:32
Definition: parser.c:55
char * LPSTR
Definition: xmlstorage.h:182
const char * filename
Definition: ioapi.h:135
HRESULT WINAPI FileSaveMarkNotExistA(LPSTR pszFileList, LPSTR pszDir, LPSTR pszBaseName)
Definition: files.c:823
#define lstrlenW
Definition: compat.h:407
#define E_FAIL
Definition: ddrawi.h:102
int32_t INT
Definition: typedefs.h:56
#define AADBE_DEL_ENTRY
Definition: advpub.h:116
HRESULT WINAPI GetVersionFromFileA(LPCSTR Filename, LPDWORD MajorVer, LPDWORD MinorVer, BOOL Version)
Definition: files.c:987
IN PVCB IN PBCB OUT PDIRENT IN USHORT IN POEM_STRING Filename
Definition: fatprocs.h:925
static IMAGE_SECTION_HEADER section
Definition: loader.c:152
#define lstrcpynW
Definition: compat.h:397
UINT WINAPI GetWindowsDirectoryW(OUT LPWSTR lpBuffer, IN UINT uSize)
Definition: path.c:2351
HRESULT WINAPI DelNodeW(LPCWSTR pszFileOrDirName, DWORD dwFlags)
Definition: files.c:432
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170
#define SPFILENOTIFY_RENAMEERROR
Definition: fileqsup.h:33
static void free_file_list(SESSION *session)
Definition: files.c:651
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
GLenum const GLfloat * params
Definition: glext.h:5645
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:90
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD WINAPI GetFileAttributesW(LPCWSTR lpFileName)
Definition: fileinfo.c:802
DWORD WINAPI GetFileAttributesA(LPCSTR lpFileName)
Definition: fileinfo.c:786
Definition: fci.h:44
#define debugstr_w
Definition: kernel32.h:32
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
#define FIXME(fmt,...)
Definition: debug.h:110
static PVOID ptr
Definition: dispmode.c:27
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
#define E_INVALIDARG
Definition: ddrawi.h:101
HRESULT WINAPI AddDelBackupEntryA(LPCSTR lpcszFileList, LPCSTR lpcszBackupDir, LPCSTR lpcszBaseName, DWORD dwFlags)
Definition: files.c:59
HRESULT WINAPI AdvInstallFileW(HWND hwnd, LPCWSTR lpszSourceDir, LPCWSTR lpszSourceFile, LPCWSTR lpszDestDir, LPCWSTR lpszDestFile, DWORD dwFlags, DWORD dwReserved)
Definition: files.c:249
smooth NULL
Definition: ftsmooth.c:416
struct tagLANGANDCODEPAGE LANGANDCODEPAGE
static LPCSTR
Definition: files.c:541
_Reserved_ PVOID Reserved
Definition: winddi.h:3974
WINE_UNICODE_INLINE long int atolW(const WCHAR *str)
Definition: unicode.h:310
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
unsigned int dir
Definition: maze.c:112
const char * LPCSTR
Definition: xmlstorage.h:183
static UINT CALLBACK pQueueCallback(PVOID Context, UINT Notification, UINT_PTR Param1, UINT_PTR Param2)
Definition: files.c:175
#define EXTRACT_FILLFILELIST
Definition: files.c:520
BOOL WINAPI RemoveDirectoryW(IN LPCWSTR lpPathName)
Definition: dir.c:732
HRESULT WINAPI GetVersionFromFileExW(LPCWSTR lpszFilename, LPDWORD pdwMSVer, LPDWORD pdwLSVer, BOOL bVersion)
Definition: files.c:1054
HRESULT WINAPI ExtractFilesA(LPCSTR CabName, LPCSTR ExpandDir, DWORD Flags, LPCSTR FileList, LPVOID LReserved, DWORD Reserved)
Definition: files.c:688
BOOL DoExtract
Definition: files.c:526
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
TConfig ini
Definition: tnconfig.cpp:45
static LPSTR convert_file_list(LPCSTR FileList, DWORD *dwNumFiles)
Definition: files.c:546
HRESULT WINAPI DelNodeRunDLL32A(HWND hWnd, HINSTANCE hInst, LPSTR cmdline, INT show)
Definition: files.c:459
#define TRACE(s)
Definition: solgame.cpp:4
#define FreeLibrary(x)
Definition: compat.h:405
HRESULT hres
Definition: protocol.c:465
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define debugstr_a
Definition: kernel32.h:31
LONG HRESULT
Definition: typedefs.h:77
BOOL WINAPI CopyFileW(IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName, IN BOOL bFailIfExists)
Definition: copy.c:439
UINT(CALLBACK * PSP_FILE_CALLBACK_W)(IN PVOID Context, IN UINT Notification, IN UINT_PTR Param1, IN UINT_PTR Param2)
Definition: fileqsup.h:66
static HMODULE hCabinet
Definition: urlmon_main.c:45
static char * heap_strdupWtoA(const WCHAR *str)
_In_ LPCSTR pszDir
Definition: shellapi.h:580
#define MAX_PATH
Definition: compat.h:26
#define WINAPI
Definition: msvc.h:8
UINT WINAPI GetTempFileNameW(IN LPCWSTR lpPathName, IN LPCWSTR lpPrefixString, IN UINT uUnique, OUT LPWSTR lpTempFileName)
Definition: filename.c:84
Definition: files.c:529
#define FILE_ATTRIBUTE_READONLY
Definition: nt_native.h:702
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
_In_ PUNICODE_STRING _Inout_ PUNICODE_STRING Destination
Definition: rtlfuncs.h:2875
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
BOOL WINAPI SetupCommitFileQueueW(IN HWND Owner, IN HSPFILEQ QueueHandle, IN PSP_FILE_CALLBACK_W MsgHandler, IN PVOID Context OPTIONAL)
Definition: fileqsup.c:617
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23
#define SPFILENOTIFY_COPYERROR
Definition: fileqsup.h:37
INT FileSize
Definition: files.c:530
ERF Error
Definition: files.c:531
LPSTR WINAPI lstrcpyA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:100
GLbitfield flags
Definition: glext.h:7161
struct FILELIST * next
Definition: files.c:525
int ret
HRESULT WINAPI FileSaveMarkNotExistW(LPWSTR pszFileList, LPWSTR pszDir, LPWSTR pszBaseName)
Definition: files.c:846
HRESULT WINAPI AdvInstallFileA(HWND hwnd, LPCSTR lpszSourceDir, LPCSTR lpszSourceFile, LPCSTR lpszDestDir, LPCSTR lpszDestFile, DWORD dwFlags, DWORD dwReserved)
Definition: files.c:196
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:126
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
UINT WINAPI SetupDefaultQueueCallbackW(PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2)
Definition: queue.c:1777
DWORD WINAPI GetFileVersionInfoSizeW(LPCWSTR filename, LPDWORD handle)
Definition: version.c:616
GLenum GLsizei len
Definition: glext.h:6722
void WINAPI SetupTermDefaultQueueCallback(PVOID context)
Definition: queue.c:1704
#define AIF_QUIET
Definition: advpub.h:127
Definition: _list.h:228
LPWSTR get_parameter(LPWSTR *params, WCHAR separator, BOOL quoted) DECLSPEC_HIDDEN
Definition: install.c:201
INT Operation
Definition: files.c:534
PVOID WINAPI SetupInitDefaultQueueCallbackEx(HWND owner, HWND progress, UINT msg, DWORD reserved1, PVOID reserved2)
Definition: queue.c:1686
static LPWSTR ansi_to_unicode_list(LPCSTR ansi_list)
Definition: files.c:40
BOOL WINAPI WritePrivateProfileStringW(LPCWSTR section, LPCWSTR entry, LPCWSTR string, LPCWSTR filename)
Definition: profile.c:1453
LPSTR FileName
Definition: files.c:524
#define S_OK
Definition: intsafe.h:59
HINSTANCE hInst
Definition: dxdiag.c:13
static unsigned __int64 next
Definition: rand_nt.c:6
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
#define lstrcpyW
Definition: compat.h:406
static calc_node_t temp
Definition: rpn_ieee.c:38
LPCWSTR szPath
Definition: env.c:35
#define list
Definition: rosglue.h:35
HRESULT WINAPI FileSaveRestoreA(HWND hDlg, LPSTR pszFileList, LPSTR pszDir, LPSTR pszBaseName, DWORD dwFlags)
Definition: files.c:859
#define FILE_ATTRIBUTE_HIDDEN
Definition: nt_native.h:703
unsigned int UINT
Definition: ndis.h:50
#define AADBE_ADD_ENTRY
Definition: advpub.h:115
#define lstrcpynA
Definition: compat.h:408
#define MultiByteToWideChar
Definition: compat.h:100
BOOL WINAPI GetFileVersionInfoW(LPCWSTR filename, DWORD handle, DWORD datasize, LPVOID data)
Definition: version.c:850
#define SPFILENOTIFY_DELETEERROR
Definition: fileqsup.h:29
HRESULT WINAPI GetVersionFromFileExA(LPCSTR lpszFilename, LPDWORD pdwMSVer, LPDWORD pdwLSVer, BOOL bVersion)
Definition: files.c:1018
GLuint res
Definition: glext.h:9613
uint32_t * LPDWORD
Definition: typedefs.h:57
HRESULT WINAPI FileSaveRestoreOnINFW(HWND hWnd, LPCWSTR pszTitle, LPCWSTR pszINF, LPCWSTR pszSection, LPCWSTR pszBackupDir, LPCWSTR pszBaseBackupFile, DWORD dwFlags)
Definition: files.c:971
HRESULT WINAPI ExtractFilesW(LPCWSTR CabName, LPCWSTR ExpandDir, DWORD Flags, LPCWSTR FileList, LPVOID LReserved, DWORD Reserved)
Definition: files.c:780
#define GetProcAddress(x, y)
Definition: compat.h:410
static UINT CALLBACK pQuietQueueCallback(PVOID Context, UINT Notification, UINT_PTR Param1, UINT_PTR Param2)
Definition: files.c:169
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
WINE_DEFAULT_DEBUG_CHANNEL(advpack)
HRESULT WINAPI AddDelBackupEntryW(LPCWSTR lpcszFileList, LPCWSTR lpcszBackupDir, LPCWSTR lpcszBaseName, DWORD dwFlags)
Definition: files.c:117
WCHAR * LPWSTR
Definition: xmlstorage.h:184
#define ROOT_LENGTH
Definition: files.c:167
HRESULT WINAPI FileSaveRestoreW(HWND hDlg, LPWSTR pszFileList, LPWSTR pszDir, LPWSTR pszBaseName, DWORD dwFlags)
Definition: files.c:904
HRESULT WINAPI FileSaveRestoreOnINFA(HWND hWnd, LPCSTR pszTitle, LPCSTR pszINF, LPCSTR pszSection, LPCSTR pszBackupDir, LPCSTR pszBaseBackupFile, DWORD dwFlags)
Definition: files.c:918
CHAR Destination[MAX_PATH]
Definition: files.c:535
static char title[]
Definition: ps.c:92
BOOL WINAPI SetupCloseFileQueue(IN HSPFILEQ QueueHandle)
Definition: fileqsup.c:217
#define HeapFree(x, y, z)
Definition: compat.h:394
#define SUCCEEDED(hr)
Definition: intsafe.h:57
static BOOL file_in_list(LPCSTR szFile, LPCSTR szFileList)
Definition: files.c:601
static BOOL heap_free(void *mem)
Definition: appwiz.h:75
HANDLE WINAPI FindFirstFileW(IN LPCWSTR lpFileName, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:320
BOOL WINAPI VerQueryValueW(LPCVOID pBlock, LPCWSTR lpSubBlock, LPVOID *lplpBuffer, PUINT puLen)
Definition: version.c:1054
BOOL WINAPI FindClose(HANDLE hFindFile)
Definition: find.c:502