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