git.oblomov.eu Git - wine/blob - 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         memcpy(lpFileFindData, &FindData, sizeof(WIN32_FIND_DATAW));
 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 = (PSECURITY_DESCRIPTOR)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 = (PSECURITY_DESCRIPTOR)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     FIXME("%d\n", dwTimeout);
 856     return WAIT_OBJECT_0;
 857 }
 858
 859 /***********************************************************************
 860  *              AssertFail  (SETUPAPI.@)
 861  *
 862  * Shows an assert fail error messagebox
 863  *
 864  * PARAMS
 865  *   lpFile [I]         file where assert failed
 866  *   uLine [I]          line number in file
 867  *   lpMessage [I]      assert message
 868  *
 869  */
 870 void WINAPI AssertFail(LPCSTR lpFile, UINT uLine, LPCSTR lpMessage)
 871 {
 872     FIXME("%s %u %s\n", lpFile, uLine, lpMessage);
 873 }
 874
 875 /***********************************************************************
 876  *      SetupCopyOEMInfA  (SETUPAPI.@)
 877  */
 878 BOOL WINAPI SetupCopyOEMInfA( PCSTR source, PCSTR location,
 879                               DWORD media_type, DWORD style, PSTR dest,
 880                               DWORD buffer_size, PDWORD required_size, PSTR *component )
 881 {
 882     BOOL ret = FALSE;
 883     LPWSTR destW = NULL, sourceW = NULL, locationW = NULL;
 884     DWORD size;
 885
 886     TRACE("%s, %s, %d, %d, %p, %d, %p, %p\n", debugstr_a(source), debugstr_a(location),
 887           media_type, style, dest, buffer_size, required_size, component);
 888
 889     if (dest && !(destW = MyMalloc( buffer_size * sizeof(WCHAR) ))) return FALSE;
 890     if (source && !(sourceW = strdupAtoW( source ))) goto done;
 891     if (location && !(locationW = strdupAtoW( location ))) goto done;
 892
 893     if (!(ret = SetupCopyOEMInfW( sourceW, locationW, media_type, style, destW,
 894                                   buffer_size, &size, NULL )))
 895     {
 896         if (required_size) *required_size = size;
 897         goto done;
 898     }
 899
 900     if (dest)
 901     {
 902         if (buffer_size >= size)
 903         {
 904             WideCharToMultiByte( CP_ACP, 0, destW, -1, dest, buffer_size, NULL, NULL );
 905             if (component) *component = strrchr( dest, '\\' ) + 1;
 906         }
 907         else
 908         {
 909             SetLastError( ERROR_INSUFFICIENT_BUFFER );
 910             goto done;
 911         }
 912     }
 913
 914 done:
 915     MyFree( destW );
 916     HeapFree( GetProcessHeap(), 0, sourceW );
 917     HeapFree( GetProcessHeap(), 0, locationW );
 918     if (ret) SetLastError(ERROR_SUCCESS);
 919     return ret;
 920 }
 921
 922 static int compare_files( HANDLE file1, HANDLE file2 )
 923 {
 924     char buffer1[2048];
 925     char buffer2[2048];
 926     DWORD size1;
 927     DWORD size2;
 928
 929     while( ReadFile(file1, buffer1, sizeof(buffer1), &size1, NULL) &&
 930            ReadFile(file2, buffer2, sizeof(buffer2), &size2, NULL) )
 931     {
 932         int ret;
 933         if (size1 != size2)
 934             return size1 > size2 ? 1 : -1;
 935         if (!size1)
 936             return 0;
 937         ret = memcmp( buffer1, buffer2, size1 );
 938         if (ret)
 939             return ret;
 940     }
 941
 942     return 0;
 943 }
 944
 945 /***********************************************************************
 946  *      SetupCopyOEMInfW  (SETUPAPI.@)
 947  */
 948 BOOL WINAPI SetupCopyOEMInfW( PCWSTR source, PCWSTR location,
 949                               DWORD media_type, DWORD style, PWSTR dest,
 950                               DWORD buffer_size, PDWORD required_size, PWSTR *component )
 951 {
 952     BOOL ret = FALSE;
 953     WCHAR target[MAX_PATH], *p;
 954     static const WCHAR inf[] = { '\\','i','n','f','\\',0 };
 955     DWORD size;
 956
 957     TRACE("%s, %s, %d, %d, %p, %d, %p, %p\n", debugstr_w(source), debugstr_w(location),
 958           media_type, style, dest, buffer_size, required_size, component);
 959
 960     if (!source)
 961     {
 962         SetLastError(ERROR_INVALID_PARAMETER);
 963         return FALSE;
 964     }
 965
 966     /* check for a relative path */
 967     if (!(*source == '\\' || (*source && source[1] == ':')))
 968     {
 969         SetLastError(ERROR_FILE_NOT_FOUND);
 970         return FALSE;
 971     }
 972
 973     if (!GetWindowsDirectoryW( target, sizeof(target)/sizeof(WCHAR) )) return FALSE;
 974
 975     strcatW( target, inf );
 976     if ((p = strrchrW( source, '\\' )))
 977         strcatW( target, p + 1 );
 978
 979     /* does the file exist already? */
 980     if ((GetFileAttributesW( target ) != INVALID_FILE_ATTRIBUTES) &&
 981         !(style & SP_COPY_NOOVERWRITE))
 982     {
 983         static const WCHAR oem[] = { 'o','e','m',0 };
 984         unsigned int i;
 985         LARGE_INTEGER source_file_size;
 986         HANDLE source_file;
 987
 988         source_file = CreateFileW( source, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
 989                                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
 990                                    NULL, OPEN_EXISTING, 0, NULL );
 991         if (source_file == INVALID_HANDLE_VALUE)
 992             return FALSE;
 993
 994         if (!GetFileSizeEx( source_file, &source_file_size ))
 995         {
 996             CloseHandle( source_file );
 997             return FALSE;
 998         }
 999
1000         p = strrchrW( target, '\\' ) + 1;
1001         memcpy( p, oem, sizeof(oem) );
1002         p += sizeof(oem)/sizeof(oem[0]) - 1;
1003
1004         /* generate OEMnnn.inf ending */
1005         for (i = 0; i < OEM_INDEX_LIMIT; i++)
1006         {
1007             static const WCHAR format[] = { '%','u','.','i','n','f',0 };
1008             HANDLE dest_file;
1009             LARGE_INTEGER dest_file_size;
1010
1011             wsprintfW( p, format, i );
1012             dest_file = CreateFileW( target, FILE_READ_DATA | FILE_READ_ATTRIBUTES,
1013                                      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1014                                      NULL, OPEN_EXISTING, 0, NULL );
1015             /* if we found a file name that doesn't exist then we're done */
1016             if (dest_file == INVALID_HANDLE_VALUE)
1017                 break;
1018             /* now check if the same inf file has already been copied to the inf
1019              * directory. if so, use that file and don't create a new one */
1020             if (!GetFileSizeEx( dest_file, &dest_file_size ) ||
1021                 (dest_file_size.QuadPart != source_file_size.QuadPart) ||
1022                 compare_files( source_file, dest_file ))
1023             {
1024                 CloseHandle( dest_file );
1025                 continue;
1026             }
1027             CloseHandle( dest_file );
1028             break;
1029         }
1030
1031         CloseHandle( source_file );
1032         if (i == OEM_INDEX_LIMIT)
1033         {
1034             SetLastError( ERROR_FILENAME_EXCED_RANGE );
1035             return FALSE;
1036         }
1037     }
1038
1039     if (!(ret = CopyFileW( source, target, (style & SP_COPY_NOOVERWRITE) != 0 )))
1040         return ret;
1041
1042     if (style & SP_COPY_DELETESOURCE)
1043         DeleteFileW( source );
1044
1045     size = strlenW( target ) + 1;
1046     if (dest)
1047     {
1048         if (buffer_size >= size)
1049         {
1050             strcpyW( dest, target );
1051         }
1052         else
1053         {
1054             SetLastError( ERROR_INSUFFICIENT_BUFFER );
1055             ret = FALSE;
1056         }
1057     }
1058
1059     if (component) *component = p + 1;
1060     if (required_size) *required_size = size;
1061     if (ret) SetLastError(ERROR_SUCCESS);
1062
1063     return ret;
1064 }
1065
1066 /***********************************************************************
1067  *      InstallCatalog  (SETUPAPI.@)
1068  */
1069 DWORD WINAPI InstallCatalog( LPCSTR catalog, LPCSTR basename, LPSTR fullname )
1070 {
1071     FIXME("%s, %s, %p\n", debugstr_a(catalog), debugstr_a(basename), fullname);
1072     return 0;
1073 }
1074
1075 static UINT detect_compression_type( LPCWSTR file )
1076 {
1077     DWORD size;
1078     HANDLE handle;
1079     UINT type = FILE_COMPRESSION_NONE;
1080     static const BYTE LZ_MAGIC[] = { 0x53, 0x5a, 0x44, 0x44, 0x88, 0xf0, 0x27, 0x33 };
1081     static const BYTE MSZIP_MAGIC[] = { 0x4b, 0x57, 0x41, 0x4a };
1082     static const BYTE NTCAB_MAGIC[] = { 0x4d, 0x53, 0x43, 0x46 };
1083     BYTE buffer[8];
1084
1085     handle = CreateFileW( file, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
1086     if (handle == INVALID_HANDLE_VALUE)
1087     {
1088         ERR("cannot open file %s\n", debugstr_w(file));
1089         return FILE_COMPRESSION_NONE;
1090     }
1091     if (!ReadFile( handle, buffer, sizeof(buffer), &size, NULL ) || size != sizeof(buffer))
1092     {
1093         CloseHandle( handle );
1094         return FILE_COMPRESSION_NONE;
1095     }
1096     if (!memcmp( buffer, LZ_MAGIC, sizeof(LZ_MAGIC) )) type = FILE_COMPRESSION_WINLZA;
1097     else if (!memcmp( buffer, MSZIP_MAGIC, sizeof(MSZIP_MAGIC) )) type = FILE_COMPRESSION_MSZIP;
1098     else if (!memcmp( buffer, NTCAB_MAGIC, sizeof(NTCAB_MAGIC) )) type = FILE_COMPRESSION_MSZIP; /* not a typo */
1099
1100     CloseHandle( handle );
1101     return type;
1102 }
1103
1104 static BOOL get_file_size( LPCWSTR file, DWORD *size )
1105 {
1106     HANDLE handle;
1107
1108     handle = CreateFileW( file, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
1109     if (handle == INVALID_HANDLE_VALUE)
1110     {
1111         ERR("cannot open file %s\n", debugstr_w(file));
1112         return FALSE;
1113     }
1114     *size = GetFileSize( handle, NULL );
1115     CloseHandle( handle );
1116     return TRUE;
1117 }
1118
1119 static BOOL get_file_sizes_none( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1120 {
1121     DWORD size;
1122
1123     if (!get_file_size( source, &size )) return FALSE;
1124     if (source_size) *source_size = size;
1125     if (target_size) *target_size = size;
1126     return TRUE;
1127 }
1128
1129 static BOOL get_file_sizes_lz( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1130 {
1131     DWORD size;
1132     BOOL ret = TRUE;
1133
1134     if (source_size)
1135     {
1136         if (!get_file_size( source, &size )) ret = FALSE;
1137         else *source_size = size;
1138     }
1139     if (target_size)
1140     {
1141         INT file;
1142         OFSTRUCT of;
1143
1144         if ((file = LZOpenFileW( (LPWSTR)source, &of, OF_READ )) < 0)
1145         {
1146             ERR("cannot open source file for reading\n");
1147             return FALSE;
1148         }
1149         *target_size = LZSeek( file, 0, 2 );
1150         LZClose( file );
1151     }
1152     return ret;
1153 }
1154
1155 static UINT CALLBACK file_compression_info_callback( PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2 )
1156 {
1157     DWORD *size = context;
1158     FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)param1;
1159
1160     switch (notification)
1161     {
1162     case SPFILENOTIFY_FILEINCABINET:
1163     {
1164         *size = info->FileSize;
1165         return FILEOP_SKIP;
1166     }
1167     default: return NO_ERROR;
1168     }
1169 }
1170
1171 static BOOL get_file_sizes_cab( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1172 {
1173     DWORD size;
1174     BOOL ret = TRUE;
1175
1176     if (source_size)
1177     {
1178         if (!get_file_size( source, &size )) ret = FALSE;
1179         else *source_size = size;
1180     }
1181     if (target_size)
1182     {
1183         ret = SetupIterateCabinetW( source, 0, file_compression_info_callback, target_size );
1184     }
1185     return ret;
1186 }
1187
1188 /***********************************************************************
1189  *      SetupGetFileCompressionInfoExA  (SETUPAPI.@)
1190  *
1191  * See SetupGetFileCompressionInfoExW.
1192  */
1193 BOOL WINAPI SetupGetFileCompressionInfoExA( PCSTR source, PSTR name, DWORD len, PDWORD required,
1194                                             PDWORD source_size, PDWORD target_size, PUINT type )
1195 {
1196     BOOL ret;
1197     WCHAR *nameW = NULL, *sourceW = NULL;
1198     DWORD nb_chars = 0;
1199     LPSTR nameA;
1200
1201     TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_a(source), name, len, required,
1202           source_size, target_size, type);
1203
1204     if (!source || !(sourceW = MultiByteToUnicode( source, CP_ACP ))) return FALSE;
1205
1206     if (name)
1207     {
1208         ret = SetupGetFileCompressionInfoExW( sourceW, NULL, 0, &nb_chars, NULL, NULL, NULL );
1209         if (!(nameW = HeapAlloc( GetProcessHeap(), 0, nb_chars * sizeof(WCHAR) )))
1210         {
1211             MyFree( sourceW );
1212             return FALSE;
1213         }
1214     }
1215     ret = SetupGetFileCompressionInfoExW( sourceW, nameW, nb_chars, &nb_chars, source_size, target_size, type );
1216     if (ret)
1217     {
1218         if ((nameA = UnicodeToMultiByte( nameW, CP_ACP )))
1219         {
1220             if (name && len >= nb_chars) lstrcpyA( name, nameA );
1221             else
1222             {
1223                 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1224                 ret = FALSE;
1225             }
1226             MyFree( nameA );
1227         }
1228     }
1229     if (required) *required = nb_chars;
1230     HeapFree( GetProcessHeap(), 0, nameW );
1231     MyFree( sourceW );
1232
1233     return ret;
1234 }
1235
1236 /***********************************************************************
1237  *      SetupGetFileCompressionInfoExW  (SETUPAPI.@)
1238  *
1239  * Get compression type and compressed/uncompressed sizes of a given file.
1240  *
1241  * PARAMS
1242  *  source      [I] File to examine.
1243  *  name        [O] Actual filename used.
1244  *  len         [I] Length in characters of 'name' buffer.
1245  *  required    [O] Number of characters written to 'name'.
1246  *  source_size [O] Size of compressed file.
1247  *  target_size [O] Size of uncompressed file.
1248  *  type        [O] Compression type.
1249  *
1250  * RETURNS
1251  *  Success: TRUE
1252  *  Failure: FALSE
1253  */
1254 BOOL WINAPI SetupGetFileCompressionInfoExW( PCWSTR source, PWSTR name, DWORD len, PDWORD required,
1255                                             PDWORD source_size, PDWORD target_size, PUINT type )
1256 {
1257     UINT comp;
1258     BOOL ret = FALSE;
1259     DWORD source_len;
1260
1261     TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_w(source), name, len, required,
1262           source_size, target_size, type);
1263
1264     if (!source) return FALSE;
1265
1266     source_len = lstrlenW( source ) + 1;
1267     if (required) *required = source_len;
1268     if (name && len >= source_len)
1269     {
1270         lstrcpyW( name, source );
1271         ret = TRUE;
1272     }
1273     else return FALSE;
1274
1275     comp = detect_compression_type( source );
1276     if (type) *type = comp;
1277
1278     switch (comp)
1279     {
1280     case FILE_COMPRESSION_MSZIP:
1281     case FILE_COMPRESSION_NTCAB:  ret = get_file_sizes_cab( source, source_size, target_size ); break;
1282     case FILE_COMPRESSION_NONE:   ret = get_file_sizes_none( source, source_size, target_size ); break;
1283     case FILE_COMPRESSION_WINLZA: ret = get_file_sizes_lz( source, source_size, target_size ); break;
1284     default: break;
1285     }
1286     return ret;
1287 }
1288
1289 /***********************************************************************
1290  *      SetupGetFileCompressionInfoA  (SETUPAPI.@)
1291  *
1292  * See SetupGetFileCompressionInfoW.
1293  */
1294 DWORD WINAPI SetupGetFileCompressionInfoA( PCSTR source, PSTR *name, PDWORD source_size,
1295                                            PDWORD target_size, PUINT type )
1296 {
1297     BOOL ret;
1298     DWORD error, required;
1299     LPSTR actual_name;
1300
1301     TRACE("%s, %p, %p, %p, %p\n", debugstr_a(source), name, source_size, target_size, type);
1302
1303     if (!source || !name || !source_size || !target_size || !type)
1304         return ERROR_INVALID_PARAMETER;
1305
1306     ret = SetupGetFileCompressionInfoExA( source, NULL, 0, &required, NULL, NULL, NULL );
1307     if (!(actual_name = MyMalloc( required ))) return ERROR_NOT_ENOUGH_MEMORY;
1308
1309     ret = SetupGetFileCompressionInfoExA( source, actual_name, required, &required,
1310                                           source_size, target_size, type );
1311     if (!ret)
1312     {
1313         error = GetLastError();
1314         MyFree( actual_name );
1315         return error;
1316     }
1317     *name = actual_name;
1318     return ERROR_SUCCESS;
1319 }
1320
1321 /***********************************************************************
1322  *      SetupGetFileCompressionInfoW  (SETUPAPI.@)
1323  *
1324  * Get compression type and compressed/uncompressed sizes of a given file.
1325  *
1326  * PARAMS
1327  *  source      [I] File to examine.
1328  *  name        [O] Actual filename used.
1329  *  source_size [O] Size of compressed file.
1330  *  target_size [O] Size of uncompressed file.
1331  *  type        [O] Compression type.
1332  *
1333  * RETURNS
1334  *  Success: ERROR_SUCCESS
1335  *  Failure: Win32 error code.
1336  */
1337 DWORD WINAPI SetupGetFileCompressionInfoW( PCWSTR source, PWSTR *name, PDWORD source_size,
1338                                            PDWORD target_size, PUINT type )
1339 {
1340     BOOL ret;
1341     DWORD error, required;
1342     LPWSTR actual_name;
1343
1344     TRACE("%s, %p, %p, %p, %p\n", debugstr_w(source), name, source_size, target_size, type);
1345
1346     if (!source || !name || !source_size || !target_size || !type)
1347         return ERROR_INVALID_PARAMETER;
1348
1349     ret = SetupGetFileCompressionInfoExW( source, NULL, 0, &required, NULL, NULL, NULL );
1350     if (!(actual_name = MyMalloc( required ))) return ERROR_NOT_ENOUGH_MEMORY;
1351
1352     ret = SetupGetFileCompressionInfoExW( source, actual_name, required, &required,
1353                                           source_size, target_size, type );
1354     if (!ret)
1355     {
1356         error = GetLastError();
1357         MyFree( actual_name );
1358         return error;
1359     }
1360     *name = actual_name;
1361     return ERROR_SUCCESS;
1362 }
1363
1364 static DWORD decompress_file_lz( LPCWSTR source, LPCWSTR target )
1365 {
1366     DWORD ret;
1367     LONG error;
1368     INT src, dst;
1369     OFSTRUCT sof, dof;
1370
1371     if ((src = LZOpenFileW( (LPWSTR)source, &sof, OF_READ )) < 0)
1372     {
1373         ERR("cannot open source file for reading\n");
1374         return ERROR_FILE_NOT_FOUND;
1375     }
1376     if ((dst = LZOpenFileW( (LPWSTR)target, &dof, OF_CREATE )) < 0)
1377     {
1378         ERR("cannot open target file for writing\n");
1379         LZClose( src );
1380         return ERROR_FILE_NOT_FOUND;
1381     }
1382     if ((error = LZCopy( src, dst )) >= 0) ret = ERROR_SUCCESS;
1383     else
1384     {
1385         WARN("failed to decompress file %d\n", error);
1386         ret = ERROR_INVALID_DATA;
1387     }
1388
1389     LZClose( src );
1390     LZClose( dst );
1391     return ret;
1392 }
1393
1394 static UINT CALLBACK decompress_or_copy_callback( PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2 )
1395 {
1396     FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)param1;
1397
1398     switch (notification)
1399     {
1400     case SPFILENOTIFY_FILEINCABINET:
1401     {
1402         LPCWSTR filename, targetname = context;
1403         WCHAR *p;
1404
1405         if ((p = strrchrW( targetname, '\\' ))) filename = p + 1;
1406         else filename = targetname;
1407
1408         if (!lstrcmpiW( filename, info->NameInCabinet ))
1409         {
1410             strcpyW( info->FullTargetName, targetname );
1411             return FILEOP_DOIT;
1412         }
1413         return FILEOP_SKIP;
1414     }
1415     default: return NO_ERROR;
1416     }
1417 }
1418
1419 static DWORD decompress_file_cab( LPCWSTR source, LPCWSTR target )
1420 {
1421     BOOL ret;
1422
1423     ret = SetupIterateCabinetW( source, 0, decompress_or_copy_callback, (PVOID)target );
1424
1425     if (ret) return ERROR_SUCCESS;
1426     else return GetLastError();
1427 }
1428
1429 /***********************************************************************
1430  *      SetupDecompressOrCopyFileA  (SETUPAPI.@)
1431  *
1432  * See SetupDecompressOrCopyFileW.
1433  */
1434 DWORD WINAPI SetupDecompressOrCopyFileA( PCSTR source, PCSTR target, PUINT type )
1435 {
1436     DWORD ret = FALSE;
1437     WCHAR *sourceW = NULL, *targetW = NULL;
1438
1439     if (source && !(sourceW = MultiByteToUnicode( source, CP_ACP ))) return FALSE;
1440     if (target && !(targetW = MultiByteToUnicode( target, CP_ACP )))
1441     {
1442         MyFree( sourceW );
1443         return ERROR_NOT_ENOUGH_MEMORY;
1444     }
1445
1446     ret = SetupDecompressOrCopyFileW( sourceW, targetW, type );
1447
1448     MyFree( sourceW );
1449     MyFree( targetW );
1450
1451     return ret;
1452 }
1453
1454 /***********************************************************************
1455  *      SetupDecompressOrCopyFileW  (SETUPAPI.@)
1456  *
1457  * Copy a file and decompress it if needed.
1458  *
1459  * PARAMS
1460  *  source [I] File to copy.
1461  *  target [I] Filename of the copy.
1462  *  type   [I] Compression type.
1463  *
1464  * RETURNS
1465  *  Success: ERROR_SUCCESS
1466  *  Failure: Win32 error code.
1467  */
1468 DWORD WINAPI SetupDecompressOrCopyFileW( PCWSTR source, PCWSTR target, PUINT type )
1469 {
1470     UINT comp;
1471     DWORD ret = ERROR_INVALID_PARAMETER;
1472
1473     if (!source || !target) return ERROR_INVALID_PARAMETER;
1474
1475     if (!type) comp = detect_compression_type( source );
1476     else comp = *type;
1477
1478     switch (comp)
1479     {
1480     case FILE_COMPRESSION_NONE:
1481         if (CopyFileW( source, target, FALSE )) ret = ERROR_SUCCESS;
1482         else ret = GetLastError();
1483         break;
1484     case FILE_COMPRESSION_WINLZA:
1485         ret = decompress_file_lz( source, target );
1486         break;
1487     case FILE_COMPRESSION_NTCAB:
1488     case FILE_COMPRESSION_MSZIP:
1489         ret = decompress_file_cab( source, target );
1490         break;
1491     default:
1492         WARN("unknown compression type %d\n", comp);
1493         break;
1494     }
1495
1496     TRACE("%s -> %s %d\n", debugstr_w(source), debugstr_w(target), comp);
1497     return ret;
1498 }