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