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