1 /*
2 * Setupapi miscellaneous functions
3 *
4 * Copyright 2005 Eric Kohl
5 * Copyright 2007 Hans Leidekker
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "wingdi.h"
27 #include "winuser.h"
28 #include "winreg.h"
29 #include "setupapi.h"
30 #include "lzexpand.h"
31
32 #include "wine/unicode.h"
33 #include "wine/debug.h"
34
35 #include "setupapi_private.h"
36
37
38 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
39
40 /* arbitrary limit not related to what native actually uses */
41 #define OEM_INDEX_LIMIT 999
42
43 /**************************************************************************
44 * MyFree [SETUPAPI.@]
45 *
46 * Frees an allocated memory block from the process heap.
47 *
48 * PARAMS
49 * lpMem [I] pointer to memory block which will be freed
50 *
51 * RETURNS
52 * None
53 */
54 VOID WINAPI MyFree(LPVOID lpMem)
55 {
56 HeapFree(GetProcessHeap(), 0, lpMem);
57 }
58
59
60 /**************************************************************************
61 * MyMalloc [SETUPAPI.@]
62 *
63 * Allocates memory block from the process heap.
64 *
65 * PARAMS
66 * dwSize [I] size of the allocated memory block
67 *
68 * RETURNS
69 * Success: pointer to allocated memory block
70 * Failure: NULL
71 */
72 LPVOID WINAPI MyMalloc(DWORD dwSize)
73 {
74 return HeapAlloc(GetProcessHeap(), 0, dwSize);
75 }
76
77
78 /**************************************************************************
79 * MyRealloc [SETUPAPI.@]
80 *
81 * Changes the size of an allocated memory block or allocates a memory
82 * block from the process heap.
83 *
84 * PARAMS
85 * lpSrc [I] pointer to memory block which will be resized
86 * dwSize [I] new size of the memory block
87 *
88 * RETURNS
89 * Success: pointer to the resized memory block
90 * Failure: NULL
91 *
92 * NOTES
93 * If lpSrc is a NULL-pointer, then MyRealloc allocates a memory
94 * block like MyMalloc.
95 */
96 LPVOID WINAPI MyRealloc(LPVOID lpSrc, DWORD dwSize)
97 {
98 if (lpSrc == NULL)
99 return HeapAlloc(GetProcessHeap(), 0, dwSize);
100
101 return HeapReAlloc(GetProcessHeap(), 0, lpSrc, dwSize);
102 }
103
104
105 /**************************************************************************
106 * DuplicateString [SETUPAPI.@]
107 *
108 * Duplicates a unicode string.
109 *
110 * PARAMS
111 * lpSrc [I] pointer to the unicode string that will be duplicated
112 *
113 * RETURNS
114 * Success: pointer to the duplicated unicode string
115 * Failure: NULL
116 *
117 * NOTES
118 * Call MyFree() to release the duplicated string.
119 */
120 LPWSTR WINAPI DuplicateString(LPCWSTR lpSrc)
121 {
122 LPWSTR lpDst;
123
124 lpDst = MyMalloc((lstrlenW(lpSrc) + 1) * sizeof(WCHAR));
125 if (lpDst == NULL)
126 return NULL;
127
128 strcpyW(lpDst, lpSrc);
129
130 return lpDst;
131 }
132
133
134 /**************************************************************************
135 * QueryRegistryValue [SETUPAPI.@]
136 *
137 * Retrieves value data from the registry and allocates memory for the
138 * value data.
139 *
140 * PARAMS
141 * hKey [I] Handle of the key to query
142 * lpValueName [I] Name of value under hkey to query
143 * lpData [O] Destination for the values contents,
144 * lpType [O] Destination for the value type
145 * lpcbData [O] Destination for the size of data
146 *
147 * RETURNS
148 * Success: ERROR_SUCCESS
149 * Failure: Otherwise
150 *
151 * NOTES
152 * Use MyFree to release the lpData buffer.
153 */
154 LONG WINAPI QueryRegistryValue(HKEY hKey,
155 LPCWSTR lpValueName,
156 LPBYTE *lpData,
157 LPDWORD lpType,
158 LPDWORD lpcbData)
159 {
160 LONG lError;
161
162 TRACE("%p %s %p %p %p\n",
163 hKey, debugstr_w(lpValueName), lpData, lpType, lpcbData);
164
165 /* Get required buffer size */
166 *lpcbData = 0;
167 lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, NULL, lpcbData);
168 if (lError != ERROR_SUCCESS)
169 return lError;
170
171 /* Allocate buffer */
172 *lpData = MyMalloc(*lpcbData);
173 if (*lpData == NULL)
174 return ERROR_NOT_ENOUGH_MEMORY;
175
176 /* Query registry value */
177 lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, *lpData, lpcbData);
178 if (lError != ERROR_SUCCESS)
179 MyFree(*lpData);
180
181 return lError;
182 }
183
184
185 /**************************************************************************
186 * IsUserAdmin [SETUPAPI.@]
187 *
188 * Checks whether the current user is a member of the Administrators group.
189 *
190 * PARAMS
191 * None
192 *
193 * RETURNS
194 * Success: TRUE
195 * Failure: FALSE
196 */
197 BOOL WINAPI IsUserAdmin(VOID)
198 {
199 SID_IDENTIFIER_AUTHORITY Authority = {SECURITY_NT_AUTHORITY};
200 HANDLE hToken;
201 DWORD dwSize;
202 PTOKEN_GROUPS lpGroups;
203 PSID lpSid;
204 DWORD i;
205 BOOL bResult = FALSE;
206
207 TRACE("\n");
208
209 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
210 {
211 return FALSE;
212 }
213
214 if (!GetTokenInformation(hToken, TokenGroups, NULL, 0, &dwSize))
215 {
216 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
217 {
218 CloseHandle(hToken);
219 return FALSE;
220 }
221 }
222
223 lpGroups = MyMalloc(dwSize);
224 if (lpGroups == NULL)
225 {
226 CloseHandle(hToken);
227 return FALSE;
228 }
229
230 if (!GetTokenInformation(hToken, TokenGroups, lpGroups, dwSize, &dwSize))
231 {
232 MyFree(lpGroups);
233 CloseHandle(hToken);
234 return FALSE;
235 }
236
237 CloseHandle(hToken);
238
239 if (!AllocateAndInitializeSid(&Authority, 2, SECURITY_BUILTIN_DOMAIN_RID,
240 DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
241 &lpSid))
242 {
243 MyFree(lpGroups);
244 return FALSE;
245 }
246
247 for (i = 0; i < lpGroups->GroupCount; i++)
248 {
249 if (EqualSid(lpSid, lpGroups->Groups[i].Sid))
250 {
251 bResult = TRUE;
252 break;
253 }
254 }
255
256 FreeSid(lpSid);
257 MyFree(lpGroups);
258
259 return bResult;
260 }
261
262
263 /**************************************************************************
264 * MultiByteToUnicode [SETUPAPI.@]
265 *
266 * Converts a multi-byte string to a Unicode string.
267 *
268 * PARAMS
269 * lpMultiByteStr [I] Multi-byte string to be converted
270 * uCodePage [I] Code page
271 *
272 * RETURNS
273 * Success: pointer to the converted Unicode string
274 * Failure: NULL
275 *
276 * NOTE
277 * Use MyFree to release the returned Unicode string.
278 */
279 LPWSTR WINAPI MultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
280 {
281 LPWSTR lpUnicodeStr;
282 int nLength;
283
284 nLength = MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
285 -1, NULL, 0);
286 if (nLength == 0)
287 return NULL;
288
289 lpUnicodeStr = MyMalloc(nLength * sizeof(WCHAR));
290 if (lpUnicodeStr == NULL)
291 return NULL;
292
293 if (!MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
294 nLength, lpUnicodeStr, nLength))
295 {
296 MyFree(lpUnicodeStr);
297 return NULL;
298 }
299
300 return lpUnicodeStr;
301 }
302
303
304 /**************************************************************************
305 * UnicodeToMultiByte [SETUPAPI.@]
306 *
307 * Converts a Unicode string to a multi-byte string.
308 *
309 * PARAMS
310 * lpUnicodeStr [I] Unicode string to be converted
311 * uCodePage [I] Code page
312 *
313 * RETURNS
314 * Success: pointer to the converted multi-byte string
315 * Failure: NULL
316 *
317 * NOTE
318 * Use MyFree to release the returned multi-byte string.
319 */
320 LPSTR WINAPI UnicodeToMultiByte(LPCWSTR lpUnicodeStr, UINT uCodePage)
321 {
322 LPSTR lpMultiByteStr;
323 int nLength;
324
325 nLength = WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
326 NULL, 0, NULL, NULL);
327 if (nLength == 0)
328 return NULL;
329
330 lpMultiByteStr = MyMalloc(nLength);
331 if (lpMultiByteStr == NULL)
332 return NULL;
333
334 if (!WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
335 lpMultiByteStr, nLength, NULL, NULL))
336 {
337 MyFree(lpMultiByteStr);
338 return NULL;
339 }
340
341 return lpMultiByteStr;
342 }
343
344
345 /**************************************************************************
346 * DoesUserHavePrivilege [SETUPAPI.@]
347 *
348 * Check whether the current user has got a given privilege.
349 *
350 * PARAMS
351 * lpPrivilegeName [I] Name of the privilege to be checked
352 *
353 * RETURNS
354 * Success: TRUE
355 * Failure: FALSE
356 */
357 BOOL WINAPI DoesUserHavePrivilege(LPCWSTR lpPrivilegeName)
358 {
359 HANDLE hToken;
360 DWORD dwSize;
361 PTOKEN_PRIVILEGES lpPrivileges;
362 LUID PrivilegeLuid;
363 DWORD i;
364 BOOL bResult = FALSE;
365
366 TRACE("%s\n", debugstr_w(lpPrivilegeName));
367
368 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
369 return FALSE;
370
371 if (!GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &dwSize))
372 {
373 if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
374 {
375 CloseHandle(hToken);
376 return FALSE;
377 }
378 }
379
380 lpPrivileges = MyMalloc(dwSize);
381 if (lpPrivileges == NULL)
382 {
383 CloseHandle(hToken);
384 return FALSE;
385 }
386
387 if (!GetTokenInformation(hToken, TokenPrivileges, lpPrivileges, dwSize, &dwSize))
388 {
389 MyFree(lpPrivileges);
390 CloseHandle(hToken);
391 return FALSE;
392 }
393
394 CloseHandle(hToken);
395
396 if (!LookupPrivilegeValueW(NULL, lpPrivilegeName, &PrivilegeLuid))
397 {
398 MyFree(lpPrivileges);
399 return FALSE;
400 }
401
402 for (i = 0; i < lpPrivileges->PrivilegeCount; i++)
403 {
404 if (lpPrivileges->Privileges[i].Luid.HighPart == PrivilegeLuid.HighPart &&
405 lpPrivileges->Privileges[i].Luid.LowPart == PrivilegeLuid.LowPart)
406 {
407 bResult = TRUE;
408 }
409 }
410
411 MyFree(lpPrivileges);
412
413 return bResult;
414 }
415
416
417 /**************************************************************************
418 * EnablePrivilege [SETUPAPI.@]
419 *
420 * Enables or disables one of the current users privileges.
421 *
422 * PARAMS
423 * lpPrivilegeName [I] Name of the privilege to be changed
424 * bEnable [I] TRUE: Enables the privilege
425 * FALSE: Disables the privilege
426 *
427 * RETURNS
428 * Success: TRUE
429 * Failure: FALSE
430 */
431 BOOL WINAPI EnablePrivilege(LPCWSTR lpPrivilegeName, BOOL bEnable)
432 {
433 TOKEN_PRIVILEGES Privileges;
434 HANDLE hToken;
435 BOOL bResult;
436
437 TRACE("%s %s\n", debugstr_w(lpPrivilegeName), bEnable ? "TRUE" : "FALSE");
438
439 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
440 return FALSE;
441
442 Privileges.PrivilegeCount = 1;
443 Privileges.Privileges[0].Attributes = (bEnable) ? SE_PRIVILEGE_ENABLED : 0;
444
445 if (!LookupPrivilegeValueW(NULL, lpPrivilegeName,
446 &Privileges.Privileges[0].Luid))
447 {
448 CloseHandle(hToken);
449 return FALSE;
450 }
451
452 bResult = AdjustTokenPrivileges(hToken, FALSE, &Privileges, 0, NULL, NULL);
453
454 CloseHandle(hToken);
455
456 return bResult;
457 }
458
459
460 /**************************************************************************
461 * DelayedMove [SETUPAPI.@]
462 *
463 * Moves a file upon the next reboot.
464 *
465 * PARAMS
466 * lpExistingFileName [I] Current file name
467 * lpNewFileName [I] New file name
468 *
469 * RETURNS
470 * Success: TRUE
471 * Failure: FALSE
472 */
473 BOOL WINAPI DelayedMove(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName)
474 {
475 return MoveFileExW(lpExistingFileName, lpNewFileName,
476 MOVEFILE_REPLACE_EXISTING | MOVEFILE_DELAY_UNTIL_REBOOT);
477 }
478
479
480 /**************************************************************************
481 * FileExists [SETUPAPI.@]
482 *
483 * Checks whether a file exists.
484 *
485 * PARAMS
486 * lpFileName [I] Name of the file to check
487 * lpNewFileName [O] Optional information about the existing file
488 *
489 * RETURNS
490 * Success: TRUE
491 * Failure: FALSE
492 */
493 BOOL WINAPI FileExists(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFileFindData)
494 {
495 WIN32_FIND_DATAW FindData;
496 HANDLE hFind;
497 UINT uErrorMode;
498 DWORD dwError;
499
500 uErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
501
502 hFind = FindFirstFileW(lpFileName, &FindData);
503 if (hFind == INVALID_HANDLE_VALUE)
504 {
505 dwError = GetLastError();
506 SetErrorMode(uErrorMode);
507 SetLastError(dwError);
508 return FALSE;
509 }
510
511 FindClose(hFind);
512
513 if (lpFileFindData)
514 *lpFileFindData = FindData;
515
516 SetErrorMode(uErrorMode);
517
518 return TRUE;
519 }
520
521
522 /**************************************************************************
523 * CaptureStringArg [SETUPAPI.@]
524 *
525 * Captures a UNICODE string.
526 *
527 * PARAMS
528 * lpSrc [I] UNICODE string to be captured
529 * lpDst [O] Pointer to the captured UNICODE string
530 *
531 * RETURNS
532 * Success: ERROR_SUCCESS
533 * Failure: ERROR_INVALID_PARAMETER
534 *
535 * NOTE
536 * Call MyFree to release the captured UNICODE string.
537 */
538 DWORD WINAPI CaptureStringArg(LPCWSTR pSrc, LPWSTR *pDst)
539 {
540 if (pDst == NULL)
541 return ERROR_INVALID_PARAMETER;
542
543 *pDst = DuplicateString(pSrc);
544
545 return ERROR_SUCCESS;
546 }
547
548
549 /**************************************************************************
550 * CaptureAndConvertAnsiArg [SETUPAPI.@]
551 *
552 * Captures an ANSI string and converts it to a UNICODE string.
553 *
554 * PARAMS
555 * lpSrc [I] ANSI string to be captured
556 * lpDst [O] Pointer to the captured UNICODE string
557 *
558 * RETURNS
559 * Success: ERROR_SUCCESS
560 * Failure: ERROR_INVALID_PARAMETER
561 *
562 * NOTE
563 * Call MyFree to release the captured UNICODE string.
564 */
565 DWORD WINAPI CaptureAndConvertAnsiArg(LPCSTR pSrc, LPWSTR *pDst)
566 {
567 if (pDst == NULL)
568 return ERROR_INVALID_PARAMETER;
569
570 *pDst = MultiByteToUnicode(pSrc, CP_ACP);
571
572 return ERROR_SUCCESS;
573 }
574
575
576 /**************************************************************************
577 * OpenAndMapFileForRead [SETUPAPI.@]
578 *
579 * Open and map a file to a buffer.
580 *
581 * PARAMS
582 * lpFileName [I] Name of the file to be opened
583 * lpSize [O] Pointer to the file size
584 * lpFile [0] Pointer to the file handle
585 * lpMapping [0] Pointer to the mapping handle
586 * lpBuffer [0] Pointer to the file buffer
587 *
588 * RETURNS
589 * Success: ERROR_SUCCESS
590 * Failure: Other
591 *
592 * NOTE
593 * Call UnmapAndCloseFile to release the file.
594 */
595 DWORD WINAPI OpenAndMapFileForRead(LPCWSTR lpFileName,
596 LPDWORD lpSize,
597 LPHANDLE lpFile,
598 LPHANDLE lpMapping,
599 LPVOID *lpBuffer)
600 {
601 DWORD dwError;
602
603 TRACE("%s %p %p %p %p\n",
604 debugstr_w(lpFileName), lpSize, lpFile, lpMapping, lpBuffer);
605
606 *lpFile = CreateFileW(lpFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
607 OPEN_EXISTING, 0, NULL);
608 if (*lpFile == INVALID_HANDLE_VALUE)
609 return GetLastError();
610
611 *lpSize = GetFileSize(*lpFile, NULL);
612 if (*lpSize == INVALID_FILE_SIZE)
613 {
614 dwError = GetLastError();
615 CloseHandle(*lpFile);
616 return dwError;
617 }
618
619 *lpMapping = CreateFileMappingW(*lpFile, NULL, PAGE_READONLY, 0,
620 *lpSize, NULL);
621 if (*lpMapping == NULL)
622 {
623 dwError = GetLastError();
624 CloseHandle(*lpFile);
625 return dwError;
626 }
627
628 *lpBuffer = MapViewOfFile(*lpMapping, FILE_MAP_READ, 0, 0, *lpSize);
629 if (*lpBuffer == NULL)
630 {
631 dwError = GetLastError();
632 CloseHandle(*lpMapping);
633 CloseHandle(*lpFile);
634 return dwError;
635 }
636
637 return ERROR_SUCCESS;
638 }
639
640
641 /**************************************************************************
642 * UnmapAndCloseFile [SETUPAPI.@]
643 *
644 * Unmap and close a mapped file.
645 *
646 * PARAMS
647 * hFile [I] Handle to the file
648 * hMapping [I] Handle to the file mapping
649 * lpBuffer [I] Pointer to the file buffer
650 *
651 * RETURNS
652 * Success: TRUE
653 * Failure: FALSE
654 */
655 BOOL WINAPI UnmapAndCloseFile(HANDLE hFile, HANDLE hMapping, LPVOID lpBuffer)
656 {
657 TRACE("%p %p %p\n",
658 hFile, hMapping, lpBuffer);
659
660 if (!UnmapViewOfFile(lpBuffer))
661 return FALSE;
662
663 if (!CloseHandle(hMapping))
664 return FALSE;
665
666 if (!CloseHandle(hFile))
667 return FALSE;
668
669 return TRUE;
670 }
671
672
673 /**************************************************************************
674 * StampFileSecurity [SETUPAPI.@]
675 *
676 * Assign a new security descriptor to the given file.
677 *
678 * PARAMS
679 * lpFileName [I] Name of the file
680 * pSecurityDescriptor [I] New security descriptor
681 *
682 * RETURNS
683 * Success: ERROR_SUCCESS
684 * Failure: other
685 */
686 DWORD WINAPI StampFileSecurity(LPCWSTR lpFileName, PSECURITY_DESCRIPTOR pSecurityDescriptor)
687 {
688 TRACE("%s %p\n", debugstr_w(lpFileName), pSecurityDescriptor);
689
690 if (!SetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
691 GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
692 pSecurityDescriptor))
693 return GetLastError();
694
695 return ERROR_SUCCESS;
696 }
697
698
699 /**************************************************************************
700 * TakeOwnershipOfFile [SETUPAPI.@]
701 *
702 * Takes the ownership of the given file.
703 *
704 * PARAMS
705 * lpFileName [I] Name of the file
706 *
707 * RETURNS
708 * Success: ERROR_SUCCESS
709 * Failure: other
710 */
711 DWORD WINAPI TakeOwnershipOfFile(LPCWSTR lpFileName)
712 {
713 SECURITY_DESCRIPTOR SecDesc;
714 HANDLE hToken = NULL;
715 PTOKEN_OWNER pOwner = NULL;
716 DWORD dwError;
717 DWORD dwSize;
718
719 TRACE("%s\n", debugstr_w(lpFileName));
720
721 if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
722 return GetLastError();
723
724 if (!GetTokenInformation(hToken, TokenOwner, NULL, 0, &dwSize))
725 {
726 goto fail;
727 }
728
729 pOwner = (PTOKEN_OWNER)MyMalloc(dwSize);
730 if (pOwner == NULL)
731 {
732 CloseHandle(hToken);
733 return ERROR_NOT_ENOUGH_MEMORY;
734 }
735
736 if (!GetTokenInformation(hToken, TokenOwner, pOwner, dwSize, &dwSize))
737 {
738 goto fail;
739 }
740
741 if (!InitializeSecurityDescriptor(&SecDesc, SECURITY_DESCRIPTOR_REVISION))
742 {
743 goto fail;
744 }
745
746 if (!SetSecurityDescriptorOwner(&SecDesc, pOwner->Owner, FALSE))
747 {
748 goto fail;
749 }
750
751 if (!SetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION, &SecDesc))
752 {
753 goto fail;
754 }
755
756 MyFree(pOwner);
757 CloseHandle(hToken);
758
759 return ERROR_SUCCESS;
760
761 fail:;
762 dwError = GetLastError();
763
764 MyFree(pOwner);
765
766 if (hToken != NULL)
767 CloseHandle(hToken);
768
769 return dwError;
770 }
771
772
773 /**************************************************************************
774 * RetreiveFileSecurity [SETUPAPI.@]
775 *
776 * Retrieve the security descriptor that is associated with the given file.
777 *
778 * PARAMS
779 * lpFileName [I] Name of the file
780 *
781 * RETURNS
782 * Success: ERROR_SUCCESS
783 * Failure: other
784 */
785 DWORD WINAPI RetreiveFileSecurity(LPCWSTR lpFileName,
786 PSECURITY_DESCRIPTOR *pSecurityDescriptor)
787 {
788 PSECURITY_DESCRIPTOR SecDesc;
789 DWORD dwSize = 0x100;
790 DWORD dwError;
791
792 SecDesc = MyMalloc(dwSize);
793 if (SecDesc == NULL)
794 return ERROR_NOT_ENOUGH_MEMORY;
795
796 if (GetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
797 GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
798 SecDesc, dwSize, &dwSize))
799 {
800 *pSecurityDescriptor = SecDesc;
801 return ERROR_SUCCESS;
802 }
803
804 dwError = GetLastError();
805 if (dwError != ERROR_INSUFFICIENT_BUFFER)
806 {
807 MyFree(SecDesc);
808 return dwError;
809 }
810
811 SecDesc = MyRealloc(SecDesc, dwSize);
812 if (SecDesc == NULL)
813 return ERROR_NOT_ENOUGH_MEMORY;
814
815 if (GetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
816 GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
817 SecDesc, dwSize, &dwSize))
818 {
819 *pSecurityDescriptor = SecDesc;
820 return ERROR_SUCCESS;
821 }
822
823 dwError = GetLastError();
824 MyFree(SecDesc);
825
826 return dwError;
827 }
828
829
830 static DWORD global_flags = 0; /* FIXME: what should be in here? */
831
832 /***********************************************************************
833 * pSetupGetGlobalFlags (SETUPAPI.@)
834 */
835 DWORD WINAPI pSetupGetGlobalFlags(void)
836 {
837 FIXME( "stub\n" );
838 return global_flags;
839 }
840
841
842 /***********************************************************************
843 * pSetupSetGlobalFlags (SETUPAPI.@)
844 */
845 void WINAPI pSetupSetGlobalFlags( DWORD flags )
846 {
847 global_flags = flags;
848 }
849
850 /***********************************************************************
851 * CMP_WaitNoPendingInstallEvents (SETUPAPI.@)
852 */
853 DWORD WINAPI CMP_WaitNoPendingInstallEvents( DWORD dwTimeout )
854 {
855 static BOOL warned = FALSE;
856
857 if (!warned)
858 {
859 FIXME("%d\n", dwTimeout);
860 warned = TRUE;
861 }
862 return WAIT_OBJECT_0;
863 }
864
865 /***********************************************************************
866 * AssertFail (SETUPAPI.@)
867 *
868 * Shows an assert fail error messagebox
869 *
870 * PARAMS
871 * lpFile [I] file where assert failed
872 * uLine [I] line number in file
873 * lpMessage [I] assert message
874 *
875 */
876 void WINAPI AssertFail(LPCSTR lpFile, UINT uLine, LPCSTR lpMessage)
877 {
878 FIXME("%s %u %s\n", lpFile, uLine, lpMessage);
879 }
880
881 /***********************************************************************
882 * SetupCopyOEMInfA (SETUPAPI.@)
883 */
884 BOOL WINAPI SetupCopyOEMInfA( PCSTR source, PCSTR location,
885 DWORD media_type, DWORD style, PSTR dest,
886 DWORD buffer_size, PDWORD required_size, PSTR *component )
887 {
888 BOOL ret = FALSE;
889 LPWSTR destW = NULL, sourceW = NULL, locationW = NULL;
890 DWORD size;
891
892 TRACE("%s, %s, %d, %d, %p, %d, %p, %p\n", debugstr_a(source), debugstr_a(location),
893 media_type, style, dest, buffer_size, required_size, component);
894
895 if (dest && !(destW = MyMalloc( buffer_size * sizeof(WCHAR) ))) return FALSE;
896 if (source && !(sourceW = strdupAtoW( source ))) goto done;
897 if (location && !(locationW = strdupAtoW( location ))) goto done;
898
899 if (!(ret = SetupCopyOEMInfW( sourceW, locationW, media_type, style, destW,
900 buffer_size, &size, NULL )))
901 {
902 if (required_size) *required_size = size;
903 goto done;
904 }
905
906 if (dest)
907 {
908 if (buffer_size >= size)
909 {
910 WideCharToMultiByte( CP_ACP, 0, destW, -1, dest, buffer_size, NULL, NULL );
911 if (component) *component = strrchr( dest, '\\' ) + 1;
912 }
913 else
914 {
915 SetLastError( ERROR_INSUFFICIENT_BUFFER );
916 goto done;
917 }
918 }
919
920 done:
921 MyFree( destW );
922 HeapFree( GetProcessHeap(), 0, sourceW );
923 HeapFree( GetProcessHeap(), 0, locationW );
924 if (ret) SetLastError(ERROR_SUCCESS);
925 return ret;
926 }
927
928 static int compare_files( HANDLE file1, HANDLE file2 )
929 {
930 char buffer1[2048];
931 char buffer2[2048];
932 DWORD size1;
933 DWORD size2;
934
935 while( ReadFile(file1, buffer1, sizeof(buffer1), &size1, NULL) &&
936 ReadFile(file2, buffer2, sizeof(buffer2), &size2, NULL) )
937 {
938 int ret;
939 if (size1 != size2)
940 return size1 > size2 ? 1 : -1;
941 if (!size1)
942 return 0;
943 ret = memcmp( buffer1, buffer2, size1 );
944 if (ret)
945 return ret;
946 }
947
948 return 0;
949 }
950
951 /***********************************************************************
952 * SetupCopyOEMInfW (SETUPAPI.@)
953 */
954 BOOL WINAPI SetupCopyOEMInfW( PCWSTR source, PCWSTR location,
955 DWORD media_type, DWORD style, PWSTR dest,
956 DWORD buffer_size, PDWORD required_size, PWSTR *component )
957 {
958 BOOL ret = FALSE;
959 WCHAR target[MAX_PATH], catalog_file[MAX_PATH], *p;
960 static const WCHAR inf[] = { '\\','i','n','f','\\',0 };
961 static const WCHAR wszVersion[] = { 'V','e','r','s','i','o','n',0 };
962 static const WCHAR wszCatalogFile[] = { 'C','a','t','a','l','o','g','F','i','l','e',0 };
963 DWORD size;
964 HINF hinf;
965
966 TRACE("%s, %s, %d, %d, %p, %d, %p, %p\n", debugstr_w(source), debugstr_w(location),
967 media_type, style, dest, buffer_size, required_size, component);
968
969 if (!source)
970 {
971 SetLastError(ERROR_INVALID_PARAMETER);
972 return FALSE;
973 }
974
975 /* check for a relative path */
976 if (!(*source == '\\' || (*source && source[1] == ':')))
977 {
978 SetLastError(ERROR_FILE_NOT_FOUND);
979 return FALSE;
980 }
981
982 if (!GetWindowsDirectoryW( target, sizeof(target)/sizeof(WCHAR) )) return FALSE;
983
984 strcatW( target, inf );
985 if ((p = strrchrW( source, '\\' )))
986 strcatW( target, p + 1 );
987
988 /* does the file exist already? */
989 if ((GetFileAttributesW( target ) != INVALID_FILE_ATTRIBUTES) &&
990 !(style & SP_COPY_NOOVERWRITE))
991 {
992 static const WCHAR oem[] = { 'o','e','m',0 };
993 unsigned int i;
994 LARGE_INTEGER source_file_size;
995 HANDLE source_file;
996
997 source_file = CreateFileW( source, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
998 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
999 NULL, OPEN_EXISTING, 0, NULL );
1000 if (source_file == INVALID_HANDLE_VALUE)
1001 return FALSE;
1002
1003 if (!GetFileSizeEx( source_file, &source_file_size ))
1004 {
1005 CloseHandle( source_file );
1006 return FALSE;
1007 }
1008
1009 p = strrchrW( target, '\\' ) + 1;
1010 memcpy( p, oem, sizeof(oem) );
1011 p += sizeof(oem)/sizeof(oem[0]) - 1;
1012
1013 /* generate OEMnnn.inf ending */
1014 for (i = 0; i < OEM_INDEX_LIMIT; i++)
1015 {
1016 static const WCHAR format[] = { '%','u','.','i','n','f',0 };
1017 HANDLE dest_file;
1018 LARGE_INTEGER dest_file_size;
1019
1020 wsprintfW( p, format, i );
1021 dest_file = CreateFileW( target, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
1022 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1023 NULL, OPEN_EXISTING, 0, NULL );
1024 /* if we found a file name that doesn't exist then we're done */
1025 if (dest_file == INVALID_HANDLE_VALUE)
1026 break;
1027 /* now check if the same inf file has already been copied to the inf
1028 * directory. if so, use that file and don't create a new one */
1029 if (!GetFileSizeEx( dest_file, &dest_file_size ) ||
1030 (dest_file_size.QuadPart != source_file_size.QuadPart) ||
1031 compare_files( source_file, dest_file ))
1032 {
1033 CloseHandle( dest_file );
1034 continue;
1035 }
1036 CloseHandle( dest_file );
1037 break;
1038 }
1039
1040 CloseHandle( source_file );
1041 if (i == OEM_INDEX_LIMIT)
1042 {
1043 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1044 return FALSE;
1045 }
1046 }
1047
1048 hinf = SetupOpenInfFileW( source, NULL, INF_STYLE_WIN4, NULL );
1049 if (hinf == INVALID_HANDLE_VALUE) return FALSE;
1050
1051 if (SetupGetLineTextW( NULL, hinf, wszVersion, wszCatalogFile, catalog_file,
1052 sizeof(catalog_file)/sizeof(catalog_file[0]), NULL ))
1053 {
1054 WCHAR source_cat[MAX_PATH];
1055 strcpyW( source_cat, source );
1056
1057 p = strrchrW( source_cat, '\\' );
1058 if (p) p++;
1059 else p = source_cat;
1060
1061 strcpyW( p, catalog_file );
1062
1063 FIXME("install catalog file %s\n", debugstr_w( source_cat ));
1064 }
1065 SetupCloseInfFile( hinf );
1066
1067 if (!(ret = CopyFileW( source, target, (style & SP_COPY_NOOVERWRITE) != 0 )))
1068 return ret;
1069
1070 if (style & SP_COPY_DELETESOURCE)
1071 DeleteFileW( source );
1072
1073 size = strlenW( target ) + 1;
1074 if (dest)
1075 {
1076 if (buffer_size >= size)
1077 {
1078 strcpyW( dest, target );
1079 }
1080 else
1081 {
1082 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1083 ret = FALSE;
1084 }
1085 }
1086
1087 if (component) *component = p + 1;
1088 if (required_size) *required_size = size;
1089 if (ret) SetLastError(ERROR_SUCCESS);
1090
1091 return ret;
1092 }
1093
1094 /***********************************************************************
1095 * InstallCatalog (SETUPAPI.@)
1096 */
1097 DWORD WINAPI InstallCatalog( LPCSTR catalog, LPCSTR basename, LPSTR fullname )
1098 {
1099 FIXME("%s, %s, %p\n", debugstr_a(catalog), debugstr_a(basename), fullname);
1100 return 0;
1101 }
1102
1103 static UINT detect_compression_type( LPCWSTR file )
1104 {
1105 DWORD size;
1106 HANDLE handle;
1107 UINT type = FILE_COMPRESSION_NONE;
1108 static const BYTE LZ_MAGIC[] = { 0x53, 0x5a, 0x44, 0x44, 0x88, 0xf0, 0x27, 0x33 };
1109 static const BYTE MSZIP_MAGIC[] = { 0x4b, 0x57, 0x41, 0x4a };
1110 static const BYTE NTCAB_MAGIC[] = { 0x4d, 0x53, 0x43, 0x46 };
1111 BYTE buffer[8];
1112
1113 handle = CreateFileW( file, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
1114 if (handle == INVALID_HANDLE_VALUE)
1115 {
1116 ERR("cannot open file %s\n", debugstr_w(file));
1117 return FILE_COMPRESSION_NONE;
1118 }
1119 if (!ReadFile( handle, buffer, sizeof(buffer), &size, NULL ) || size != sizeof(buffer))
1120 {
1121 CloseHandle( handle );
1122 return FILE_COMPRESSION_NONE;
1123 }
1124 if (!memcmp( buffer, LZ_MAGIC, sizeof(LZ_MAGIC) )) type = FILE_COMPRESSION_WINLZA;
1125 else if (!memcmp( buffer, MSZIP_MAGIC, sizeof(MSZIP_MAGIC) )) type = FILE_COMPRESSION_MSZIP;
1126 else if (!memcmp( buffer, NTCAB_MAGIC, sizeof(NTCAB_MAGIC) )) type = FILE_COMPRESSION_MSZIP; /* not a typo */
1127
1128 CloseHandle( handle );
1129 return type;
1130 }
1131
1132 static BOOL get_file_size( LPCWSTR file, DWORD *size )
1133 {
1134 HANDLE handle;
1135
1136 handle = CreateFileW( file, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
1137 if (handle == INVALID_HANDLE_VALUE)
1138 {
1139 ERR("cannot open file %s\n", debugstr_w(file));
1140 return FALSE;
1141 }
1142 *size = GetFileSize( handle, NULL );
1143 CloseHandle( handle );
1144 return TRUE;
1145 }
1146
1147 static BOOL get_file_sizes_none( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1148 {
1149 DWORD size;
1150
1151 if (!get_file_size( source, &size )) return FALSE;
1152 if (source_size) *source_size = size;
1153 if (target_size) *target_size = size;
1154 return TRUE;
1155 }
1156
1157 static BOOL get_file_sizes_lz( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1158 {
1159 DWORD size;
1160 BOOL ret = TRUE;
1161
1162 if (source_size)
1163 {
1164 if (!get_file_size( source, &size )) ret = FALSE;
1165 else *source_size = size;
1166 }
1167 if (target_size)
1168 {
1169 INT file;
1170 OFSTRUCT of;
1171
1172 if ((file = LZOpenFileW( (LPWSTR)source, &of, OF_READ )) < 0)
1173 {
1174 ERR("cannot open source file for reading\n");
1175 return FALSE;
1176 }
1177 *target_size = LZSeek( file, 0, 2 );
1178 LZClose( file );
1179 }
1180 return ret;
1181 }
1182
1183 static UINT CALLBACK file_compression_info_callback( PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2 )
1184 {
1185 DWORD *size = context;
1186 FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)param1;
1187
1188 switch (notification)
1189 {
1190 case SPFILENOTIFY_FILEINCABINET:
1191 {
1192 *size = info->FileSize;
1193 return FILEOP_SKIP;
1194 }
1195 default: return NO_ERROR;
1196 }
1197 }
1198
1199 static BOOL get_file_sizes_cab( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1200 {
1201 DWORD size;
1202 BOOL ret = TRUE;
1203
1204 if (source_size)
1205 {
1206 if (!get_file_size( source, &size )) ret = FALSE;
1207 else *source_size = size;
1208 }
1209 if (target_size)
1210 {
1211 ret = SetupIterateCabinetW( source, 0, file_compression_info_callback, target_size );
1212 }
1213 return ret;
1214 }
1215
1216 /***********************************************************************
1217 * SetupGetFileCompressionInfoExA (SETUPAPI.@)
1218 *
1219 * See SetupGetFileCompressionInfoExW.
1220 */
1221 BOOL WINAPI SetupGetFileCompressionInfoExA( PCSTR source, PSTR name, DWORD len, PDWORD required,
1222 PDWORD source_size, PDWORD target_size, PUINT type )
1223 {
1224 BOOL ret;
1225 WCHAR *nameW = NULL, *sourceW = NULL;
1226 DWORD nb_chars = 0;
1227 LPSTR nameA;
1228
1229 TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_a(source), name, len, required,
1230 source_size, target_size, type);
1231
1232 if (!source || !(sourceW = MultiByteToUnicode( source, CP_ACP ))) return FALSE;
1233
1234 if (name)
1235 {
1236 ret = SetupGetFileCompressionInfoExW( sourceW, NULL, 0, &nb_chars, NULL, NULL, NULL );
1237 if (!(nameW = HeapAlloc( GetProcessHeap(), 0, nb_chars * sizeof(WCHAR) )))
1238 {
1239 MyFree( sourceW );
1240 return FALSE;
1241 }
1242 }
1243 ret = SetupGetFileCompressionInfoExW( sourceW, nameW, nb_chars, &nb_chars, source_size, target_size, type );
1244 if (ret)
1245 {
1246 if ((nameA = UnicodeToMultiByte( nameW, CP_ACP )))
1247 {
1248 if (name && len >= nb_chars) lstrcpyA( name, nameA );
1249 else
1250 {
1251 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1252 ret = FALSE;
1253 }
1254 MyFree( nameA );
1255 }
1256 }
1257 if (required) *required = nb_chars;
1258 HeapFree( GetProcessHeap(), 0, nameW );
1259 MyFree( sourceW );
1260
1261 return ret;
1262 }
1263
1264 /***********************************************************************
1265 * SetupGetFileCompressionInfoExW (SETUPAPI.@)
1266 *
1267 * Get compression type and compressed/uncompressed sizes of a given file.
1268 *
1269 * PARAMS
1270 * source [I] File to examine.
1271 * name [O] Actual filename used.
1272 * len [I] Length in characters of 'name' buffer.
1273 * required [O] Number of characters written to 'name'.
1274 * source_size [O] Size of compressed file.
1275 * target_size [O] Size of uncompressed file.
1276 * type [O] Compression type.
1277 *
1278 * RETURNS
1279 * Success: TRUE
1280 * Failure: FALSE
1281 */
1282 BOOL WINAPI SetupGetFileCompressionInfoExW( PCWSTR source, PWSTR name, DWORD len, PDWORD required,
1283 PDWORD source_size, PDWORD target_size, PUINT type )
1284 {
1285 UINT comp;
1286 BOOL ret = FALSE;
1287 DWORD source_len;
1288
1289 TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_w(source), name, len, required,
1290 source_size, target_size, type);
1291
1292 if (!source) return FALSE;
1293
1294 source_len = lstrlenW( source ) + 1;
1295 if (required) *required = source_len;
1296 if (name && len >= source_len)
1297 {
1298 lstrcpyW( name, source );
1299 ret = TRUE;
1300 }
1301 else return FALSE;
1302
1303 comp = detect_compression_type( source );
1304 if (type) *type = comp;
1305
1306 switch (comp)
1307 {
1308 case FILE_COMPRESSION_MSZIP:
1309 case FILE_COMPRESSION_NTCAB: ret = get_file_sizes_cab( source, source_size, target_size ); break;
1310 case FILE_COMPRESSION_NONE: ret = get_file_sizes_none( source, source_size, target_size ); break;
1311 case FILE_COMPRESSION_WINLZA: ret = get_file_sizes_lz( source, source_size, target_size ); break;
1312 default: break;
1313 }
1314 return ret;
1315 }
1316
1317 /***********************************************************************
1318 * SetupGetFileCompressionInfoA (SETUPAPI.@)
1319 *
1320 * See SetupGetFileCompressionInfoW.
1321 */
1322 DWORD WINAPI SetupGetFileCompressionInfoA( PCSTR source, PSTR *name, PDWORD source_size,
1323 PDWORD target_size, PUINT type )
1324 {
1325 BOOL ret;
1326 DWORD error, required;
1327 LPSTR actual_name;
1328
1329 TRACE("%s, %p, %p, %p, %p\n", debugstr_a(source), name, source_size, target_size, type);
1330
1331 if (!source || !name || !source_size || !target_size || !type)
1332 return ERROR_INVALID_PARAMETER;
1333
1334 ret = SetupGetFileCompressionInfoExA( source, NULL, 0, &required, NULL, NULL, NULL );
1335 if (!(actual_name = MyMalloc( required ))) return ERROR_NOT_ENOUGH_MEMORY;
1336
1337 ret = SetupGetFileCompressionInfoExA( source, actual_name, required, &required,
1338 source_size, target_size, type );
1339 if (!ret)
1340 {
1341 error = GetLastError();
1342 MyFree( actual_name );
1343 return error;
1344 }
1345 *name = actual_name;
1346 return ERROR_SUCCESS;
1347 }
1348
1349 /***********************************************************************
1350 * SetupGetFileCompressionInfoW (SETUPAPI.@)
1351 *
1352 * Get compression type and compressed/uncompressed sizes of a given file.
1353 *
1354 * PARAMS
1355 * source [I] File to examine.
1356 * name [O] Actual filename used.
1357 * source_size [O] Size of compressed file.
1358 * target_size [O] Size of uncompressed file.
1359 * type [O] Compression type.
1360 *
1361 * RETURNS
1362 * Success: ERROR_SUCCESS
1363 * Failure: Win32 error code.
1364 */
1365 DWORD WINAPI SetupGetFileCompressionInfoW( PCWSTR source, PWSTR *name, PDWORD source_size,
1366 PDWORD target_size, PUINT type )
1367 {
1368 BOOL ret;
1369 DWORD error, required;
1370 LPWSTR actual_name;
1371
1372 TRACE("%s, %p, %p, %p, %p\n", debugstr_w(source), name, source_size, target_size, type);
1373
1374 if (!source || !name || !source_size || !target_size || !type)
1375 return ERROR_INVALID_PARAMETER;
1376
1377 ret = SetupGetFileCompressionInfoExW( source, NULL, 0, &required, NULL, NULL, NULL );
1378 if (!(actual_name = MyMalloc( required ))) return ERROR_NOT_ENOUGH_MEMORY;
1379
1380 ret = SetupGetFileCompressionInfoExW( source, actual_name, required, &required,
1381 source_size, target_size, type );
1382 if (!ret)
1383 {
1384 error = GetLastError();
1385 MyFree( actual_name );
1386 return error;
1387 }
1388 *name = actual_name;
1389 return ERROR_SUCCESS;
1390 }
1391
1392 static DWORD decompress_file_lz( LPCWSTR source, LPCWSTR target )
1393 {
1394 DWORD ret;
1395 LONG error;
1396 INT src, dst;
1397 OFSTRUCT sof, dof;
1398
1399 if ((src = LZOpenFileW( (LPWSTR)source, &sof, OF_READ )) < 0)
1400 {
1401 ERR("cannot open source file for reading\n");
1402 return ERROR_FILE_NOT_FOUND;
1403 }
1404 if ((dst = LZOpenFileW( (LPWSTR)target, &dof, OF_CREATE )) < 0)
1405 {
1406 ERR("cannot open target file for writing\n");
1407 LZClose( src );
1408 return ERROR_FILE_NOT_FOUND;
1409 }
1410 if ((error = LZCopy( src, dst )) >= 0) ret = ERROR_SUCCESS;
1411 else
1412 {
1413 WARN("failed to decompress file %d\n", error);
1414 ret = ERROR_INVALID_DATA;
1415 }
1416
1417 LZClose( src );
1418 LZClose( dst );
1419 return ret;
1420 }
1421
1422 static UINT CALLBACK decompress_or_copy_callback( PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2 )
1423 {
1424 FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)param1;
1425
1426 switch (notification)
1427 {
1428 case SPFILENOTIFY_FILEINCABINET:
1429 {
1430 LPCWSTR filename, targetname = context;
1431 WCHAR *p;
1432
1433 if ((p = strrchrW( targetname, '\\' ))) filename = p + 1;
1434 else filename = targetname;
1435
1436 if (!lstrcmpiW( filename, info->NameInCabinet ))
1437 {
1438 strcpyW( info->FullTargetName, targetname );
1439 return FILEOP_DOIT;
1440 }
1441 return FILEOP_SKIP;
1442 }
1443 default: return NO_ERROR;
1444 }
1445 }
1446
1447 static DWORD decompress_file_cab( LPCWSTR source, LPCWSTR target )
1448 {
1449 BOOL ret;
1450
1451 ret = SetupIterateCabinetW( source, 0, decompress_or_copy_callback, (PVOID)target );
1452
1453 if (ret) return ERROR_SUCCESS;
1454 else return GetLastError();
1455 }
1456
1457 /***********************************************************************
1458 * SetupDecompressOrCopyFileA (SETUPAPI.@)
1459 *
1460 * See SetupDecompressOrCopyFileW.
1461 */
1462 DWORD WINAPI SetupDecompressOrCopyFileA( PCSTR source, PCSTR target, PUINT type )
1463 {
1464 DWORD ret = FALSE;
1465 WCHAR *sourceW = NULL, *targetW = NULL;
1466
1467 if (source && !(sourceW = MultiByteToUnicode( source, CP_ACP ))) return FALSE;
1468 if (target && !(targetW = MultiByteToUnicode( target, CP_ACP )))
1469 {
1470 MyFree( sourceW );
1471 return ERROR_NOT_ENOUGH_MEMORY;
1472 }
1473
1474 ret = SetupDecompressOrCopyFileW( sourceW, targetW, type );
1475
1476 MyFree( sourceW );
1477 MyFree( targetW );
1478
1479 return ret;
1480 }
1481
1482 /***********************************************************************
1483 * SetupDecompressOrCopyFileW (SETUPAPI.@)
1484 *
1485 * Copy a file and decompress it if needed.
1486 *
1487 * PARAMS
1488 * source [I] File to copy.
1489 * target [I] Filename of the copy.
1490 * type [I] Compression type.
1491 *
1492 * RETURNS
1493 * Success: ERROR_SUCCESS
1494 * Failure: Win32 error code.
1495 */
1496 DWORD WINAPI SetupDecompressOrCopyFileW( PCWSTR source, PCWSTR target, PUINT type )
1497 {
1498 UINT comp;
1499 DWORD ret = ERROR_INVALID_PARAMETER;
1500
1501 if (!source || !target) return ERROR_INVALID_PARAMETER;
1502
1503 if (!type) comp = detect_compression_type( source );
1504 else comp = *type;
1505
1506 switch (comp)
1507 {
1508 case FILE_COMPRESSION_NONE:
1509 if (CopyFileW( source, target, FALSE )) ret = ERROR_SUCCESS;
1510 else ret = GetLastError();
1511 break;
1512 case FILE_COMPRESSION_WINLZA:
1513 ret = decompress_file_lz( source, target );
1514 break;
1515 case FILE_COMPRESSION_NTCAB:
1516 case FILE_COMPRESSION_MSZIP:
1517 ret = decompress_file_cab( source, target );
1518 break;
1519 default:
1520 WARN("unknown compression type %d\n", comp);
1521 break;
1522 }
1523
1524 TRACE("%s -> %s %d\n", debugstr_w(source), debugstr_w(target), comp);
1525 return ret;
1526 }
1527
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.