dlls/setupapi/misc.c

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