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  *      InstallCatalog  (SETUPAPI.@)
1118  */
1119 DWORD WINAPI InstallCatalog( LPCSTR catalog, LPCSTR basename, LPSTR fullname )
1120 {
1121     FIXME("%s, %s, %p\n", debugstr_a(catalog), debugstr_a(basename), fullname);
1122     return 0;
1123 }
1124
1125 /***********************************************************************
1126  *      pSetupInstallCatalog  (SETUPAPI.@)
1127  */
1128 DWORD WINAPI pSetupInstallCatalog( LPCWSTR catalog, LPCWSTR basename, LPWSTR fullname )
1129 {
1130     HCATADMIN admin;
1131     HCATINFO cat;
1132
1133     TRACE ("%s, %s, %p\n", debugstr_w(catalog), debugstr_w(basename), fullname);
1134
1135     if (!CryptCATAdminAcquireContext(&admin,NULL,0))
1136         return GetLastError();
1137
1138     if (!(cat = CryptCATAdminAddCatalog( admin, (PWSTR)catalog, (PWSTR)basename, 0 )))
1139     {
1140         DWORD rc = GetLastError();
1141         CryptCATAdminReleaseContext(admin, 0);
1142         return rc;
1143     }
1144     CryptCATAdminReleaseCatalogContext(admin, cat, 0);
1145     CryptCATAdminReleaseContext(admin,0);
1146
1147     if (fullname)
1148         FIXME("not returning full installed catalog path\n");
1149
1150     return NO_ERROR;
1151 }
1152
1153 static UINT detect_compression_type( LPCWSTR file )
1154 {
1155     DWORD size;
1156     HANDLE handle;
1157     UINT type = FILE_COMPRESSION_NONE;
1158     static const BYTE LZ_MAGIC[] = { 0x53, 0x5a, 0x44, 0x44, 0x88, 0xf0, 0x27, 0x33 };
1159     static const BYTE MSZIP_MAGIC[] = { 0x4b, 0x57, 0x41, 0x4a };
1160     static const BYTE NTCAB_MAGIC[] = { 0x4d, 0x53, 0x43, 0x46 };
1161     BYTE buffer[8];
1162
1163     handle = CreateFileW( file, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
1164     if (handle == INVALID_HANDLE_VALUE)
1165     {
1166         ERR("cannot open file %s\n", debugstr_w(file));
1167         return FILE_COMPRESSION_NONE;
1168     }
1169     if (!ReadFile( handle, buffer, sizeof(buffer), &size, NULL ) || size != sizeof(buffer))
1170     {
1171         CloseHandle( handle );
1172         return FILE_COMPRESSION_NONE;
1173     }
1174     if (!memcmp( buffer, LZ_MAGIC, sizeof(LZ_MAGIC) )) type = FILE_COMPRESSION_WINLZA;
1175     else if (!memcmp( buffer, MSZIP_MAGIC, sizeof(MSZIP_MAGIC) )) type = FILE_COMPRESSION_MSZIP;
1176     else if (!memcmp( buffer, NTCAB_MAGIC, sizeof(NTCAB_MAGIC) )) type = FILE_COMPRESSION_MSZIP; /* not a typo */
1177
1178     CloseHandle( handle );
1179     return type;
1180 }
1181
1182 static BOOL get_file_size( LPCWSTR file, DWORD *size )
1183 {
1184     HANDLE handle;
1185
1186     handle = CreateFileW( file, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL );
1187     if (handle == INVALID_HANDLE_VALUE)
1188     {
1189         ERR("cannot open file %s\n", debugstr_w(file));
1190         return FALSE;
1191     }
1192     *size = GetFileSize( handle, NULL );
1193     CloseHandle( handle );
1194     return TRUE;
1195 }
1196
1197 static BOOL get_file_sizes_none( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1198 {
1199     DWORD size;
1200
1201     if (!get_file_size( source, &size )) return FALSE;
1202     if (source_size) *source_size = size;
1203     if (target_size) *target_size = size;
1204     return TRUE;
1205 }
1206
1207 static BOOL get_file_sizes_lz( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1208 {
1209     DWORD size;
1210     BOOL ret = TRUE;
1211
1212     if (source_size)
1213     {
1214         if (!get_file_size( source, &size )) ret = FALSE;
1215         else *source_size = size;
1216     }
1217     if (target_size)
1218     {
1219         INT file;
1220         OFSTRUCT of;
1221
1222         if ((file = LZOpenFileW( (LPWSTR)source, &of, OF_READ )) < 0)
1223         {
1224             ERR("cannot open source file for reading\n");
1225             return FALSE;
1226         }
1227         *target_size = LZSeek( file, 0, 2 );
1228         LZClose( file );
1229     }
1230     return ret;
1231 }
1232
1233 static UINT CALLBACK file_compression_info_callback( PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2 )
1234 {
1235     DWORD *size = context;
1236     FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)param1;
1237
1238     switch (notification)
1239     {
1240     case SPFILENOTIFY_FILEINCABINET:
1241     {
1242         *size = info->FileSize;
1243         return FILEOP_SKIP;
1244     }
1245     default: return NO_ERROR;
1246     }
1247 }
1248
1249 static BOOL get_file_sizes_cab( LPCWSTR source, DWORD *source_size, DWORD *target_size )
1250 {
1251     DWORD size;
1252     BOOL ret = TRUE;
1253
1254     if (source_size)
1255     {
1256         if (!get_file_size( source, &size )) ret = FALSE;
1257         else *source_size = size;
1258     }
1259     if (target_size)
1260     {
1261         ret = SetupIterateCabinetW( source, 0, file_compression_info_callback, target_size );
1262     }
1263     return ret;
1264 }
1265
1266 /***********************************************************************
1267  *      SetupGetFileCompressionInfoExA  (SETUPAPI.@)
1268  *
1269  * See SetupGetFileCompressionInfoExW.
1270  */
1271 BOOL WINAPI SetupGetFileCompressionInfoExA( PCSTR source, PSTR name, DWORD len, PDWORD required,
1272                                             PDWORD source_size, PDWORD target_size, PUINT type )
1273 {
1274     BOOL ret;
1275     WCHAR *nameW = NULL, *sourceW = NULL;
1276     DWORD nb_chars = 0;
1277     LPSTR nameA;
1278
1279     TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_a(source), name, len, required,
1280           source_size, target_size, type);
1281
1282     if (!source || !(sourceW = MultiByteToUnicode( source, CP_ACP ))) return FALSE;
1283
1284     if (name)
1285     {
1286         ret = SetupGetFileCompressionInfoExW( sourceW, NULL, 0, &nb_chars, NULL, NULL, NULL );
1287         if (!(nameW = HeapAlloc( GetProcessHeap(), 0, nb_chars * sizeof(WCHAR) )))
1288         {
1289             MyFree( sourceW );
1290             return FALSE;
1291         }
1292     }
1293     ret = SetupGetFileCompressionInfoExW( sourceW, nameW, nb_chars, &nb_chars, source_size, target_size, type );
1294     if (ret)
1295     {
1296         if ((nameA = UnicodeToMultiByte( nameW, CP_ACP )))
1297         {
1298             if (name && len >= nb_chars) lstrcpyA( name, nameA );
1299             else
1300             {
1301                 SetLastError( ERROR_INSUFFICIENT_BUFFER );
1302                 ret = FALSE;
1303             }
1304             MyFree( nameA );
1305         }
1306     }
1307     if (required) *required = nb_chars;
1308     HeapFree( GetProcessHeap(), 0, nameW );
1309     MyFree( sourceW );
1310
1311     return ret;
1312 }
1313
1314 /***********************************************************************
1315  *      SetupGetFileCompressionInfoExW  (SETUPAPI.@)
1316  *
1317  * Get compression type and compressed/uncompressed sizes of a given file.
1318  *
1319  * PARAMS
1320  *  source      [I] File to examine.
1321  *  name        [O] Actual filename used.
1322  *  len         [I] Length in characters of 'name' buffer.
1323  *  required    [O] Number of characters written to 'name'.
1324  *  source_size [O] Size of compressed file.
1325  *  target_size [O] Size of uncompressed file.
1326  *  type        [O] Compression type.
1327  *
1328  * RETURNS
1329  *  Success: TRUE
1330  *  Failure: FALSE
1331  */
1332 BOOL WINAPI SetupGetFileCompressionInfoExW( PCWSTR source, PWSTR name, DWORD len, PDWORD required,
1333                                             PDWORD source_size, PDWORD target_size, PUINT type )
1334 {
1335     UINT comp;
1336     BOOL ret = FALSE;
1337     DWORD source_len;
1338
1339     TRACE("%s, %p, %d, %p, %p, %p, %p\n", debugstr_w(source), name, len, required,
1340           source_size, target_size, type);
1341
1342     if (!source) return FALSE;
1343
1344     source_len = lstrlenW( source ) + 1;
1345     if (required) *required = source_len;
1346     if (name && len >= source_len)
1347     {
1348         lstrcpyW( name, source );
1349         ret = TRUE;
1350     }
1351     else return FALSE;
1352
1353     comp = detect_compression_type( source );
1354     if (type) *type = comp;
1355
1356     switch (comp)
1357     {
1358     case FILE_COMPRESSION_MSZIP:
1359     case FILE_COMPRESSION_NTCAB:  ret = get_file_sizes_cab( source, source_size, target_size ); break;
1360     case FILE_COMPRESSION_NONE:   ret = get_file_sizes_none( source, source_size, target_size ); break;
1361     case FILE_COMPRESSION_WINLZA: ret = get_file_sizes_lz( source, source_size, target_size ); break;
1362     default: break;
1363     }
1364     return ret;
1365 }
1366
1367 /***********************************************************************
1368  *      SetupGetFileCompressionInfoA  (SETUPAPI.@)
1369  *
1370  * See SetupGetFileCompressionInfoW.
1371  */
1372 DWORD WINAPI SetupGetFileCompressionInfoA( PCSTR source, PSTR *name, PDWORD source_size,
1373                                            PDWORD target_size, PUINT type )
1374 {
1375     BOOL ret;
1376     DWORD error, required;
1377     LPSTR actual_name;
1378
1379     TRACE("%s, %p, %p, %p, %p\n", debugstr_a(source), name, source_size, target_size, type);
1380
1381     if (!source || !name || !source_size || !target_size || !type)
1382         return ERROR_INVALID_PARAMETER;
1383
1384     ret = SetupGetFileCompressionInfoExA( source, NULL, 0, &required, NULL, NULL, NULL );
1385     if (!(actual_name = MyMalloc( required ))) return ERROR_NOT_ENOUGH_MEMORY;
1386
1387     ret = SetupGetFileCompressionInfoExA( source, actual_name, required, &required,
1388                                           source_size, target_size, type );
1389     if (!ret)
1390     {
1391         error = GetLastError();
1392         MyFree( actual_name );
1393         return error;
1394     }
1395     *name = actual_name;
1396     return ERROR_SUCCESS;
1397 }
1398
1399 /***********************************************************************
1400  *      SetupGetFileCompressionInfoW  (SETUPAPI.@)
1401  *
1402  * Get compression type and compressed/uncompressed sizes of a given file.
1403  *
1404  * PARAMS
1405  *  source      [I] File to examine.
1406  *  name        [O] Actual filename used.
1407  *  source_size [O] Size of compressed file.
1408  *  target_size [O] Size of uncompressed file.
1409  *  type        [O] Compression type.
1410  *
1411  * RETURNS
1412  *  Success: ERROR_SUCCESS
1413  *  Failure: Win32 error code.
1414  */
1415 DWORD WINAPI SetupGetFileCompressionInfoW( PCWSTR source, PWSTR *name, PDWORD source_size,
1416                                            PDWORD target_size, PUINT type )
1417 {
1418     BOOL ret;
1419     DWORD error, required;
1420     LPWSTR actual_name;
1421
1422     TRACE("%s, %p, %p, %p, %p\n", debugstr_w(source), name, source_size, target_size, type);
1423
1424     if (!source || !name || !source_size || !target_size || !type)
1425         return ERROR_INVALID_PARAMETER;
1426
1427     ret = SetupGetFileCompressionInfoExW( source, NULL, 0, &required, NULL, NULL, NULL );
1428     if (!(actual_name = MyMalloc( required ))) return ERROR_NOT_ENOUGH_MEMORY;
1429
1430     ret = SetupGetFileCompressionInfoExW( source, actual_name, required, &required,
1431                                           source_size, target_size, type );
1432     if (!ret)
1433     {
1434         error = GetLastError();
1435         MyFree( actual_name );
1436         return error;
1437     }
1438     *name = actual_name;
1439     return ERROR_SUCCESS;
1440 }
1441
1442 static DWORD decompress_file_lz( LPCWSTR source, LPCWSTR target )
1443 {
1444     DWORD ret;
1445     LONG error;
1446     INT src, dst;
1447     OFSTRUCT sof, dof;
1448
1449     if ((src = LZOpenFileW( (LPWSTR)source, &sof, OF_READ )) < 0)
1450     {
1451         ERR("cannot open source file for reading\n");
1452         return ERROR_FILE_NOT_FOUND;
1453     }
1454     if ((dst = LZOpenFileW( (LPWSTR)target, &dof, OF_CREATE )) < 0)
1455     {
1456         ERR("cannot open target file for writing\n");
1457         LZClose( src );
1458         return ERROR_FILE_NOT_FOUND;
1459     }
1460     if ((error = LZCopy( src, dst )) >= 0) ret = ERROR_SUCCESS;
1461     else
1462     {
1463         WARN("failed to decompress file %d\n", error);
1464         ret = ERROR_INVALID_DATA;
1465     }
1466
1467     LZClose( src );
1468     LZClose( dst );
1469     return ret;
1470 }
1471
1472 static UINT CALLBACK decompress_or_copy_callback( PVOID context, UINT notification, UINT_PTR param1, UINT_PTR param2 )
1473 {
1474     FILE_IN_CABINET_INFO_W *info = (FILE_IN_CABINET_INFO_W *)param1;
1475
1476     switch (notification)
1477     {
1478     case SPFILENOTIFY_FILEINCABINET:
1479     {
1480         LPCWSTR filename, targetname = context;
1481         WCHAR *p;
1482
1483         if ((p = strrchrW( targetname, '\\' ))) filename = p + 1;
1484         else filename = targetname;
1485
1486         if (!lstrcmpiW( filename, info->NameInCabinet ))
1487         {
1488             strcpyW( info->FullTargetName, targetname );
1489             return FILEOP_DOIT;
1490         }
1491         return FILEOP_SKIP;
1492     }
1493     default: return NO_ERROR;
1494     }
1495 }
1496
1497 static DWORD decompress_file_cab( LPCWSTR source, LPCWSTR target )
1498 {
1499     BOOL ret;
1500
1501     ret = SetupIterateCabinetW( source, 0, decompress_or_copy_callback, (PVOID)target );
1502
1503     if (ret) return ERROR_SUCCESS;
1504     else return GetLastError();
1505 }
1506
1507 /***********************************************************************
1508  *      SetupDecompressOrCopyFileA  (SETUPAPI.@)
1509  *
1510  * See SetupDecompressOrCopyFileW.
1511  */
1512 DWORD WINAPI SetupDecompressOrCopyFileA( PCSTR source, PCSTR target, PUINT type )
1513 {
1514     DWORD ret = FALSE;
1515     WCHAR *sourceW = NULL, *targetW = NULL;
1516
1517     if (source && !(sourceW = MultiByteToUnicode( source, CP_ACP ))) return FALSE;
1518     if (target && !(targetW = MultiByteToUnicode( target, CP_ACP )))
1519     {
1520         MyFree( sourceW );
1521         return ERROR_NOT_ENOUGH_MEMORY;
1522     }
1523
1524     ret = SetupDecompressOrCopyFileW( sourceW, targetW, type );
1525
1526     MyFree( sourceW );
1527     MyFree( targetW );
1528
1529     return ret;
1530 }
1531
1532 /***********************************************************************
1533  *      SetupDecompressOrCopyFileW  (SETUPAPI.@)
1534  *
1535  * Copy a file and decompress it if needed.
1536  *
1537  * PARAMS
1538  *  source [I] File to copy.
1539  *  target [I] Filename of the copy.
1540  *  type   [I] Compression type.
1541  *
1542  * RETURNS
1543  *  Success: ERROR_SUCCESS
1544  *  Failure: Win32 error code.
1545  */
1546 DWORD WINAPI SetupDecompressOrCopyFileW( PCWSTR source, PCWSTR target, PUINT type )
1547 {
1548     UINT comp;
1549     DWORD ret = ERROR_INVALID_PARAMETER;
1550
1551     if (!source || !target) return ERROR_INVALID_PARAMETER;
1552
1553     if (!type) comp = detect_compression_type( source );
1554     else comp = *type;
1555
1556     switch (comp)
1557     {
1558     case FILE_COMPRESSION_NONE:
1559         if (CopyFileW( source, target, FALSE )) ret = ERROR_SUCCESS;
1560         else ret = GetLastError();
1561         break;
1562     case FILE_COMPRESSION_WINLZA:
1563         ret = decompress_file_lz( source, target );
1564         break;
1565     case FILE_COMPRESSION_NTCAB:
1566     case FILE_COMPRESSION_MSZIP:
1567         ret = decompress_file_cab( source, target );
1568         break;
1569     default:
1570         WARN("unknown compression type %d\n", comp);
1571         break;
1572     }
1573
1574     TRACE("%s -> %s %d\n", debugstr_w(source), debugstr_w(target), comp);
1575     return ret;
1576 }