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