shell32/tests: Compare instead of assign.
[wine] / dlls / setupapi / misc.c
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 }