dlls/setupapi/misc.c

   1 /*
   2  * Setupapi miscellaneous functions
   3  *
   4  * Copyright 2005 Eric Kohl
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "wingdi.h"
  26 #include "winuser.h"
  27 #include "winreg.h"
  28 #include "setupapi.h"
  29
  30 #include "wine/unicode.h"
  31 #include "wine/debug.h"
  32
  33 #include "setupapi_private.h"
  34
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(setupapi);
  37
  38
  39 /**************************************************************************
  40  * MyFree [SETUPAPI.@]
  41  *
  42  * Frees an allocated memory block from the process heap.
  43  *
  44  * PARAMS
  45  *     lpMem [I] pointer to memory block which will be freed
  46  *
  47  * RETURNS
  48  *     None
  49  */
  50 VOID WINAPI MyFree(LPVOID lpMem)
  51 {
  52     TRACE("%p\n", lpMem);
  53     HeapFree(GetProcessHeap(), 0, lpMem);
  54 }
  55
  56
  57 /**************************************************************************
  58  * MyMalloc [SETUPAPI.@]
  59  *
  60  * Allocates memory block from the process heap.
  61  *
  62  * PARAMS
  63  *     dwSize [I] size of the allocated memory block
  64  *
  65  * RETURNS
  66  *     Success: pointer to allocated memory block
  67  *     Failure: NULL
  68  */
  69 LPVOID WINAPI MyMalloc(DWORD dwSize)
  70 {
  71     TRACE("%lu\n", dwSize);
  72     return HeapAlloc(GetProcessHeap(), 0, dwSize);
  73 }
  74
  75
  76 /**************************************************************************
  77  * MyRealloc [SETUPAPI.@]
  78  *
  79  * Changes the size of an allocated memory block or allocates a memory
  80  * block from the process heap.
  81  *
  82  * PARAMS
  83  *     lpSrc  [I] pointer to memory block which will be resized
  84  *     dwSize [I] new size of the memory block
  85  *
  86  * RETURNS
  87  *     Success: pointer to the resized memory block
  88  *     Failure: NULL
  89  *
  90  * NOTES
  91  *     If lpSrc is a NULL-pointer, then MyRealloc allocates a memory
  92  *     block like MyMalloc.
  93  */
  94 LPVOID WINAPI MyRealloc(LPVOID lpSrc, DWORD dwSize)
  95 {
  96     TRACE("%p %lu\n", lpSrc, dwSize);
  97
  98     if (lpSrc == NULL)
  99         return HeapAlloc(GetProcessHeap(), 0, dwSize);
 100
 101     return HeapReAlloc(GetProcessHeap(), 0, lpSrc, dwSize);
 102 }
 103
 104
 105 /**************************************************************************
 106  * DuplicateString [SETUPAPI.@]
 107  *
 108  * Duplicates a unicode string.
 109  *
 110  * PARAMS
 111  *     lpSrc  [I] pointer to the unicode string that will be duplicated
 112  *
 113  * RETURNS
 114  *     Success: pointer to the duplicated unicode string
 115  *     Failure: NULL
 116  *
 117  * NOTES
 118  *     Call MyFree() to release the duplicated string.
 119  */
 120 LPWSTR WINAPI DuplicateString(LPCWSTR lpSrc)
 121 {
 122     LPWSTR lpDst;
 123
 124     TRACE("%s\n", debugstr_w(lpSrc));
 125
 126     lpDst = MyMalloc((lstrlenW(lpSrc) + 1) * sizeof(WCHAR));
 127     if (lpDst == NULL)
 128         return NULL;
 129
 130     strcpyW(lpDst, lpSrc);
 131
 132     return lpDst;
 133 }
 134
 135
 136 /**************************************************************************
 137  * QueryRegistryValue [SETUPAPI.@]
 138  *
 139  * Retrieves value data from the registry and allocates memory for the
 140  * value data.
 141  *
 142  * PARAMS
 143  *     hKey        [I] Handle of the key to query
 144  *     lpValueName [I] Name of value under hkey to query
 145  *     lpData      [O] Destination for the values contents,
 146  *     lpType      [O] Destination for the value type
 147  *     lpcbData    [O] Destination for the size of data
 148  *
 149  * RETURNS
 150  *     Success: ERROR_SUCCESS
 151  *     Failure: Otherwise
 152  *
 153  * NOTES
 154  *     Use MyFree to release the lpData buffer.
 155  */
 156 LONG WINAPI QueryRegistryValue(HKEY hKey,
 157                                LPCWSTR lpValueName,
 158                                LPBYTE  *lpData,
 159                                LPDWORD lpType,
 160                                LPDWORD lpcbData)
 161 {
 162     LONG lError;
 163
 164     TRACE("%p %s %p %p %p\n",
 165           hKey, debugstr_w(lpValueName), lpData, lpType, lpcbData);
 166
 167     /* Get required buffer size */
 168     *lpcbData = 0;
 169     lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, NULL, lpcbData);
 170     if (lError != ERROR_SUCCESS)
 171         return lError;
 172
 173     /* Allocate buffer */
 174     *lpData = MyMalloc(*lpcbData);
 175     if (*lpData == NULL)
 176         return ERROR_NOT_ENOUGH_MEMORY;
 177
 178     /* Query registry value */
 179     lError = RegQueryValueExW(hKey, lpValueName, 0, lpType, *lpData, lpcbData);
 180     if (lError != ERROR_SUCCESS)
 181         MyFree(*lpData);
 182
 183     return lError;
 184 }
 185
 186
 187 /**************************************************************************
 188  * IsUserAdmin [SETUPAPI.@]
 189  *
 190  * Checks whether the current user is a member of the Administrators group.
 191  *
 192  * PARAMS
 193  *     None
 194  *
 195  * RETURNS
 196  *     Success: TRUE
 197  *     Failure: FALSE
 198  */
 199 BOOL WINAPI IsUserAdmin(VOID)
 200 {
 201     SID_IDENTIFIER_AUTHORITY Authority = {SECURITY_NT_AUTHORITY};
 202     HANDLE hToken;
 203     DWORD dwSize;
 204     PTOKEN_GROUPS lpGroups;
 205     PSID lpSid;
 206     DWORD i;
 207     BOOL bResult = FALSE;
 208
 209     TRACE("\n");
 210
 211     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
 212     {
 213         return FALSE;
 214     }
 215
 216     if (!GetTokenInformation(hToken, TokenGroups, NULL, 0, &dwSize))
 217     {
 218         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
 219         {
 220             CloseHandle(hToken);
 221             return FALSE;
 222         }
 223     }
 224
 225     lpGroups = MyMalloc(dwSize);
 226     if (lpGroups == NULL)
 227     {
 228         CloseHandle(hToken);
 229         return FALSE;
 230     }
 231
 232     if (!GetTokenInformation(hToken, TokenGroups, lpGroups, dwSize, &dwSize))
 233     {
 234         MyFree(lpGroups);
 235         CloseHandle(hToken);
 236         return FALSE;
 237     }
 238
 239     CloseHandle(hToken);
 240
 241     if (!AllocateAndInitializeSid(&Authority, 2, SECURITY_BUILTIN_DOMAIN_RID,
 242                                   DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0,
 243                                   &lpSid))
 244     {
 245         MyFree(lpGroups);
 246         return FALSE;
 247     }
 248
 249     for (i = 0; i < lpGroups->GroupCount; i++)
 250     {
 251         if (EqualSid(lpSid, &lpGroups->Groups[i].Sid))
 252         {
 253             bResult = TRUE;
 254             break;
 255         }
 256     }
 257
 258     FreeSid(lpSid);
 259     MyFree(lpGroups);
 260
 261     return bResult;
 262 }
 263
 264
 265 /**************************************************************************
 266  * MultiByteToUnicode [SETUPAPI.@]
 267  *
 268  * Converts a multi-byte string to a Unicode string.
 269  *
 270  * PARAMS
 271  *     lpMultiByteStr  [I] Multi-byte string to be converted
 272  *     uCodePage       [I] Code page
 273  *
 274  * RETURNS
 275  *     Success: pointer to the converted Unicode string
 276  *     Failure: NULL
 277  *
 278  * NOTE
 279  *     Use MyFree to release the returned Unicode string.
 280  */
 281 LPWSTR WINAPI MultiByteToUnicode(LPCSTR lpMultiByteStr, UINT uCodePage)
 282 {
 283     LPWSTR lpUnicodeStr;
 284     int nLength;
 285
 286     TRACE("%s %d\n", debugstr_a(lpMultiByteStr), uCodePage);
 287
 288     nLength = MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
 289                                   -1, NULL, 0);
 290     if (nLength == 0)
 291         return NULL;
 292
 293     lpUnicodeStr = MyMalloc(nLength * sizeof(WCHAR));
 294     if (lpUnicodeStr == NULL)
 295         return NULL;
 296
 297     if (!MultiByteToWideChar(uCodePage, 0, lpMultiByteStr,
 298                              nLength, lpUnicodeStr, nLength))
 299     {
 300         MyFree(lpUnicodeStr);
 301         return NULL;
 302     }
 303
 304     return lpUnicodeStr;
 305 }
 306
 307
 308 /**************************************************************************
 309  * UnicodeToMultiByte [SETUPAPI.@]
 310  *
 311  * Converts a Unicode string to a multi-byte string.
 312  *
 313  * PARAMS
 314  *     lpUnicodeStr  [I] Unicode string to be converted
 315  *     uCodePage     [I] Code page
 316  *
 317  * RETURNS
 318  *     Success: pointer to the converted multi-byte string
 319  *     Failure: NULL
 320  *
 321  * NOTE
 322  *     Use MyFree to release the returned multi-byte string.
 323  */
 324 LPSTR WINAPI UnicodeToMultiByte(LPCWSTR lpUnicodeStr, UINT uCodePage)
 325 {
 326     LPSTR lpMultiByteStr;
 327     int nLength;
 328
 329     TRACE("%s %d\n", debugstr_w(lpUnicodeStr), uCodePage);
 330
 331     nLength = WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
 332                                   NULL, 0, NULL, NULL);
 333     if (nLength == 0)
 334         return NULL;
 335
 336     lpMultiByteStr = MyMalloc(nLength);
 337     if (lpMultiByteStr == NULL)
 338         return NULL;
 339
 340     if (!WideCharToMultiByte(uCodePage, 0, lpUnicodeStr, -1,
 341                              lpMultiByteStr, nLength, NULL, NULL))
 342     {
 343         MyFree(lpMultiByteStr);
 344         return NULL;
 345     }
 346
 347     return lpMultiByteStr;
 348 }
 349
 350
 351 /**************************************************************************
 352  * DoesUserHavePrivilege [SETUPAPI.@]
 353  *
 354  * Check whether the current user has got a given privilege.
 355  *
 356  * PARAMS
 357  *     lpPrivilegeName  [I] Name of the privilege to be checked
 358  *
 359  * RETURNS
 360  *     Success: TRUE
 361  *     Failure: FALSE
 362  */
 363 BOOL WINAPI DoesUserHavePrivilege(LPCWSTR lpPrivilegeName)
 364 {
 365     HANDLE hToken;
 366     DWORD dwSize;
 367     PTOKEN_PRIVILEGES lpPrivileges;
 368     LUID PrivilegeLuid;
 369     DWORD i;
 370     BOOL bResult = FALSE;
 371
 372     TRACE("%s\n", debugstr_w(lpPrivilegeName));
 373
 374     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
 375         return FALSE;
 376
 377     if (!GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &dwSize))
 378     {
 379         if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
 380         {
 381             CloseHandle(hToken);
 382             return FALSE;
 383         }
 384     }
 385
 386     lpPrivileges = MyMalloc(dwSize);
 387     if (lpPrivileges == NULL)
 388     {
 389         CloseHandle(hToken);
 390         return FALSE;
 391     }
 392
 393     if (!GetTokenInformation(hToken, TokenPrivileges, lpPrivileges, dwSize, &dwSize))
 394     {
 395         MyFree(lpPrivileges);
 396         CloseHandle(hToken);
 397         return FALSE;
 398     }
 399
 400     CloseHandle(hToken);
 401
 402     if (!LookupPrivilegeValueW(NULL, lpPrivilegeName, &PrivilegeLuid))
 403     {
 404         MyFree(lpPrivileges);
 405         return FALSE;
 406     }
 407
 408     for (i = 0; i < lpPrivileges->PrivilegeCount; i++)
 409     {
 410         if (lpPrivileges->Privileges[i].Luid.HighPart == PrivilegeLuid.HighPart &&
 411             lpPrivileges->Privileges[i].Luid.LowPart == PrivilegeLuid.LowPart)
 412         {
 413             bResult = TRUE;
 414         }
 415     }
 416
 417     MyFree(lpPrivileges);
 418
 419     return bResult;
 420 }
 421
 422
 423 /**************************************************************************
 424  * EnablePrivilege [SETUPAPI.@]
 425  *
 426  * Enables or disables one of the current users privileges.
 427  *
 428  * PARAMS
 429  *     lpPrivilegeName  [I] Name of the privilege to be changed
 430  *     bEnable          [I] TRUE: Enables the privilege
 431  *                          FALSE: Disables the privilege
 432  *
 433  * RETURNS
 434  *     Success: TRUE
 435  *     Failure: FALSE
 436  */
 437 BOOL WINAPI EnablePrivilege(LPCWSTR lpPrivilegeName, BOOL bEnable)
 438 {
 439     TOKEN_PRIVILEGES Privileges;
 440     HANDLE hToken;
 441     BOOL bResult;
 442
 443     TRACE("%s %s\n", debugstr_w(lpPrivilegeName), bEnable ? "TRUE" : "FALSE");
 444
 445     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
 446         return FALSE;
 447
 448     Privileges.PrivilegeCount = 1;
 449     Privileges.Privileges[0].Attributes = (bEnable) ? SE_PRIVILEGE_ENABLED : 0;
 450
 451     if (!LookupPrivilegeValueW(NULL, lpPrivilegeName,
 452                                &Privileges.Privileges[0].Luid))
 453     {
 454         CloseHandle(hToken);
 455         return FALSE;
 456     }
 457
 458     bResult = AdjustTokenPrivileges(hToken, FALSE, &Privileges, 0, NULL, NULL);
 459
 460     CloseHandle(hToken);
 461
 462     return bResult;
 463 }
 464
 465
 466 /**************************************************************************
 467  * DelayedMove [SETUPAPI.@]
 468  *
 469  * Moves a file upon the next reboot.
 470  *
 471  * PARAMS
 472  *     lpExistingFileName  [I] Current file name
 473  *     lpNewFileName       [I] New file name
 474  *
 475  * RETURNS
 476  *     Success: TRUE
 477  *     Failure: FALSE
 478  */
 479 BOOL WINAPI DelayedMove(LPCWSTR lpExistingFileName, LPCWSTR lpNewFileName)
 480 {
 481     return MoveFileExW(lpExistingFileName, lpNewFileName,
 482                        MOVEFILE_REPLACE_EXISTING | MOVEFILE_DELAY_UNTIL_REBOOT);
 483 }
 484
 485
 486 /**************************************************************************
 487  * FileExists [SETUPAPI.@]
 488  *
 489  * Checks whether a file exists.
 490  *
 491  * PARAMS
 492  *     lpFileName     [I] Name of the file to check
 493  *     lpNewFileName  [O] Optional information about the existing file
 494  *
 495  * RETURNS
 496  *     Success: TRUE
 497  *     Failure: FALSE
 498  */
 499 BOOL WINAPI FileExists(LPCWSTR lpFileName, LPWIN32_FIND_DATAW lpFileFindData)
 500 {
 501     WIN32_FIND_DATAW FindData;
 502     HANDLE hFind;
 503     UINT uErrorMode;
 504     DWORD dwError;
 505
 506     uErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
 507
 508     hFind = FindFirstFileW(lpFileName, &FindData);
 509     if (hFind == INVALID_HANDLE_VALUE)
 510     {
 511         dwError = GetLastError();
 512         SetErrorMode(uErrorMode);
 513         SetLastError(dwError);
 514         return FALSE;
 515     }
 516
 517     FindClose(hFind);
 518
 519     if (lpFileFindData)
 520         memcpy(lpFileFindData, &FindData, sizeof(WIN32_FIND_DATAW));
 521
 522     SetErrorMode(uErrorMode);
 523
 524     return TRUE;
 525 }
 526
 527
 528 /**************************************************************************
 529  * CaptureStringArg [SETUPAPI.@]
 530  *
 531  * Captures a UNICODE string.
 532  *
 533  * PARAMS
 534  *     lpSrc  [I] UNICODE string to be captured
 535  *     lpDst  [O] Pointer to the captured UNICODE string
 536  *
 537  * RETURNS
 538  *     Success: ERROR_SUCCESS
 539  *     Failure: ERROR_INVALID_PARAMETER
 540  *
 541  * NOTE
 542  *     Call MyFree to release the captured UNICODE string.
 543  */
 544 DWORD WINAPI CaptureStringArg(LPCWSTR pSrc, LPWSTR *pDst)
 545 {
 546     if (pDst == NULL)
 547         return ERROR_INVALID_PARAMETER;
 548
 549     *pDst = DuplicateString(pSrc);
 550
 551     return ERROR_SUCCESS;
 552 }
 553
 554
 555 /**************************************************************************
 556  * CaptureAndConvertAnsiArg [SETUPAPI.@]
 557  *
 558  * Captures an ANSI string and converts it to a UNICODE string.
 559  *
 560  * PARAMS
 561  *     lpSrc  [I] ANSI string to be captured
 562  *     lpDst  [O] Pointer to the captured UNICODE string
 563  *
 564  * RETURNS
 565  *     Success: ERROR_SUCCESS
 566  *     Failure: ERROR_INVALID_PARAMETER
 567  *
 568  * NOTE
 569  *     Call MyFree to release the captured UNICODE string.
 570  */
 571 DWORD WINAPI CaptureAndConvertAnsiArg(LPCSTR pSrc, LPWSTR *pDst)
 572 {
 573     if (pDst == NULL)
 574         return ERROR_INVALID_PARAMETER;
 575
 576     *pDst = MultiByteToUnicode(pSrc, CP_ACP);
 577
 578     return ERROR_SUCCESS;
 579 }
 580
 581
 582 /**************************************************************************
 583  * OpenAndMapFileForRead [SETUPAPI.@]
 584  *
 585  * Open and map a file to a buffer.
 586  *
 587  * PARAMS
 588  *     lpFileName [I] Name of the file to be opened
 589  *     lpSize     [O] Pointer to the file size
 590  *     lpFile     [0] Pointer to the file handle
 591  *     lpMapping  [0] Pointer to the mapping handle
 592  *     lpBuffer   [0] Pointer to the file buffer
 593  *
 594  * RETURNS
 595  *     Success: ERROR_SUCCESS
 596  *     Failure: Other
 597  *
 598  * NOTE
 599  *     Call UnmapAndCloseFile to release the file.
 600  */
 601 DWORD WINAPI OpenAndMapFileForRead(LPCWSTR lpFileName,
 602                                    LPDWORD lpSize,
 603                                    LPHANDLE lpFile,
 604                                    LPHANDLE lpMapping,
 605                                    LPVOID *lpBuffer)
 606 {
 607     DWORD dwError;
 608
 609     TRACE("%s %p %p %p %p\n",
 610           debugstr_w(lpFileName), lpSize, lpFile, lpMapping, lpBuffer);
 611
 612     *lpFile = CreateFileW(lpFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
 613                           OPEN_EXISTING, 0, NULL);
 614     if (*lpFile == INVALID_HANDLE_VALUE)
 615         return GetLastError();
 616
 617     *lpSize = GetFileSize(*lpFile, NULL);
 618     if (*lpSize == INVALID_FILE_SIZE)
 619     {
 620         dwError = GetLastError();
 621         CloseHandle(*lpFile);
 622         return dwError;
 623     }
 624
 625     *lpMapping = CreateFileMappingW(*lpFile, NULL, PAGE_READONLY, 0,
 626                                     *lpSize, NULL);
 627     if (*lpMapping == NULL)
 628     {
 629         dwError = GetLastError();
 630         CloseHandle(*lpFile);
 631         return dwError;
 632     }
 633
 634     *lpBuffer = MapViewOfFile(*lpMapping, FILE_MAP_READ, 0, 0, *lpSize);
 635     if (*lpBuffer == NULL)
 636     {
 637         dwError = GetLastError();
 638         CloseHandle(*lpMapping);
 639         CloseHandle(*lpFile);
 640         return dwError;
 641     }
 642
 643     return ERROR_SUCCESS;
 644 }
 645
 646
 647 /**************************************************************************
 648  * UnmapAndCloseFile [SETUPAPI.@]
 649  *
 650  * Unmap and close a mapped file.
 651  *
 652  * PARAMS
 653  *     hFile    [I] Handle to the file
 654  *     hMapping [I] Handle to the file mapping
 655  *     lpBuffer [I] Pointer to the file buffer
 656  *
 657  * RETURNS
 658  *     Success: TRUE
 659  *     Failure: FALSE
 660  */
 661 BOOL WINAPI UnmapAndCloseFile(HANDLE hFile, HANDLE hMapping, LPVOID lpBuffer)
 662 {
 663     TRACE("%p %p %p\n",
 664           hFile, hMapping, lpBuffer);
 665
 666     if (!UnmapViewOfFile(lpBuffer))
 667         return FALSE;
 668
 669     if (!CloseHandle(hMapping))
 670         return FALSE;
 671
 672     if (!CloseHandle(hFile))
 673         return FALSE;
 674
 675     return TRUE;
 676 }
 677
 678
 679 /**************************************************************************
 680  * StampFileSecurity [SETUPAPI.@]
 681  *
 682  * Assign a new security descriptor to the given file.
 683  *
 684  * PARAMS
 685  *     lpFileName          [I] Name of the file
 686  *     pSecurityDescriptor [I] New security descriptor
 687  *
 688  * RETURNS
 689  *     Success: ERROR_SUCCESS
 690  *     Failure: other
 691  */
 692 DWORD WINAPI StampFileSecurity(LPCWSTR lpFileName, PSECURITY_DESCRIPTOR pSecurityDescriptor)
 693 {
 694     TRACE("%s %p\n", debugstr_w(lpFileName), pSecurityDescriptor);
 695
 696     if (!SetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
 697                           GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
 698                           pSecurityDescriptor))
 699         return GetLastError();
 700
 701     return ERROR_SUCCESS;
 702 }
 703
 704
 705 /**************************************************************************
 706  * TakeOwnershipOfFile [SETUPAPI.@]
 707  *
 708  * Takes the ownership of the given file.
 709  *
 710  * PARAMS
 711  *     lpFileName [I] Name of the file
 712  *
 713  * RETURNS
 714  *     Success: ERROR_SUCCESS
 715  *     Failure: other
 716  */
 717 DWORD WINAPI TakeOwnershipOfFile(LPCWSTR lpFileName)
 718 {
 719     SECURITY_DESCRIPTOR SecDesc;
 720     HANDLE hToken = NULL;
 721     PTOKEN_OWNER pOwner = NULL;
 722     DWORD dwError;
 723     DWORD dwSize;
 724
 725     TRACE("%s\n", debugstr_w(lpFileName));
 726
 727     if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
 728         return GetLastError();
 729
 730     if (!GetTokenInformation(hToken, TokenOwner, NULL, 0, &dwSize))
 731     {
 732         goto fail;
 733     }
 734
 735     pOwner = (PTOKEN_OWNER)MyMalloc(dwSize);
 736     if (pOwner == NULL)
 737     {
 738         CloseHandle(hToken);
 739         return ERROR_NOT_ENOUGH_MEMORY;
 740     }
 741
 742     if (!GetTokenInformation(hToken, TokenOwner, pOwner, dwSize, &dwSize))
 743     {
 744         goto fail;
 745     }
 746
 747     if (!InitializeSecurityDescriptor(&SecDesc, SECURITY_DESCRIPTOR_REVISION))
 748     {
 749         goto fail;
 750     }
 751
 752     if (!SetSecurityDescriptorOwner(&SecDesc, pOwner->Owner, FALSE))
 753     {
 754         goto fail;
 755     }
 756
 757     if (!SetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION, &SecDesc))
 758     {
 759         goto fail;
 760     }
 761
 762     MyFree(pOwner);
 763     CloseHandle(hToken);
 764
 765     return ERROR_SUCCESS;
 766
 767 fail:;
 768     dwError = GetLastError();
 769
 770     if (pOwner != NULL)
 771         MyFree(pOwner);
 772
 773     if (hToken != NULL)
 774         CloseHandle(hToken);
 775
 776     return dwError;
 777 }
 778
 779
 780 /**************************************************************************
 781  * RetreiveFileSecurity [SETUPAPI.@]
 782  *
 783  * Retrieve the security descriptor that is associated with the given file.
 784  *
 785  * PARAMS
 786  *     lpFileName [I] Name of the file
 787  *
 788  * RETURNS
 789  *     Success: ERROR_SUCCESS
 790  *     Failure: other
 791  */
 792 DWORD WINAPI RetreiveFileSecurity(LPCWSTR lpFileName,
 793                                   PSECURITY_DESCRIPTOR *pSecurityDescriptor)
 794 {
 795     PSECURITY_DESCRIPTOR SecDesc;
 796     DWORD dwSize = 0x100;
 797     DWORD dwError;
 798
 799     SecDesc = (PSECURITY_DESCRIPTOR)MyMalloc(dwSize);
 800     if (SecDesc == NULL)
 801         return ERROR_NOT_ENOUGH_MEMORY;
 802
 803     if (GetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
 804                          GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
 805                          SecDesc, dwSize, &dwSize))
 806     {
 807       *pSecurityDescriptor = SecDesc;
 808       return ERROR_SUCCESS;
 809     }
 810
 811     dwError = GetLastError();
 812     if (dwError != ERROR_INSUFFICIENT_BUFFER)
 813     {
 814         MyFree(SecDesc);
 815         return dwError;
 816     }
 817
 818     SecDesc = (PSECURITY_DESCRIPTOR)MyRealloc(SecDesc, dwSize);
 819     if (SecDesc == NULL)
 820         return ERROR_NOT_ENOUGH_MEMORY;
 821
 822     if (GetFileSecurityW(lpFileName, OWNER_SECURITY_INFORMATION |
 823                          GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION,
 824                          SecDesc, dwSize, &dwSize))
 825     {
 826       *pSecurityDescriptor = SecDesc;
 827       return ERROR_SUCCESS;
 828     }
 829
 830     dwError = GetLastError();
 831     MyFree(SecDesc);
 832
 833     return dwError;
 834 }