git.oblomov.eu Git - wine/blob - dlls/advapi32/security.c

   1 /*
   2  * Copyright 1999, 2000 Juergen Schmied <juergen.schmied@debitel.net>
   3  * Copyright 2003 CodeWeavers Inc. (Ulrich Czekalla)
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include <stdarg.h>
  22 #include <string.h>
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winerror.h"
  27 #include "rpcnterr.h"
  28 #include "winreg.h"
  29 #include "winternl.h"
  30 #include "winioctl.h"
  31 #include "ntstatus.h"
  32 #include "ntsecapi.h"
  33 #include "accctrl.h"
  34 #include "sddl.h"
  35 #include "winsvc.h"
  36 #include "aclapi.h"
  37
  38 #include "wine/debug.h"
  39 #include "wine/unicode.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
  42
  43 static BOOL ParseStringSidToSid(LPCWSTR StringSid, PSID pSid, LPDWORD cBytes);
  44 static BOOL ParseStringAclToAcl(LPCWSTR StringAcl, LPDWORD lpdwFlags,
  45     PACL pAcl, LPDWORD cBytes);
  46 static BYTE ParseAceStringFlags(LPCWSTR* StringAcl);
  47 static BYTE ParseAceStringType(LPCWSTR* StringAcl);
  48 static DWORD ParseAceStringRights(LPCWSTR* StringAcl);
  49 static BOOL ParseStringSecurityDescriptorToSecurityDescriptor(
  50     LPCWSTR StringSecurityDescriptor,
  51     SECURITY_DESCRIPTOR* SecurityDescriptor,
  52     LPDWORD cBytes);
  53 static DWORD ParseAclStringFlags(LPCWSTR* StringAcl);
  54
  55 typedef struct _ACEFLAG
  56 {
  57    LPCWSTR wstr;
  58    DWORD value;
  59 } ACEFLAG, *LPACEFLAG;
  60
  61 static SID const sidWorld = { SID_REVISION, 1, { SECURITY_WORLD_SID_AUTHORITY} , { SECURITY_WORLD_RID } };
  62
  63 /*
  64  * ACE access rights
  65  */
  66 static const WCHAR SDDL_READ_CONTROL[]     = {'R','C',0};
  67 static const WCHAR SDDL_WRITE_DAC[]        = {'W','D',0};
  68 static const WCHAR SDDL_WRITE_OWNER[]      = {'W','O',0};
  69 static const WCHAR SDDL_STANDARD_DELETE[]  = {'S','D',0};
  70 static const WCHAR SDDL_GENERIC_ALL[]      = {'G','A',0};
  71 static const WCHAR SDDL_GENERIC_READ[]     = {'G','R',0};
  72 static const WCHAR SDDL_GENERIC_WRITE[]    = {'G','W',0};
  73 static const WCHAR SDDL_GENERIC_EXECUTE[]  = {'G','X',0};
  74
  75 /*
  76  * ACE types
  77  */
  78 static const WCHAR SDDL_ACCESS_ALLOWED[]        = {'A',0};
  79 static const WCHAR SDDL_ACCESS_DENIED[]         = {'D',0};
  80 static const WCHAR SDDL_OBJECT_ACCESS_ALLOWED[] = {'O','A',0};
  81 static const WCHAR SDDL_OBJECT_ACCESS_DENIED[]  = {'O','D',0};
  82 static const WCHAR SDDL_AUDIT[]                 = {'A','U',0};
  83 static const WCHAR SDDL_ALARM[]                 = {'A','L',0};
  84 static const WCHAR SDDL_OBJECT_AUDIT[]          = {'O','U',0};
  85 static const WCHAR SDDL_OBJECT_ALARMp[]         = {'O','L',0};
  86
  87 /*
  88  * ACE flags
  89  */
  90 static const WCHAR SDDL_CONTAINER_INHERIT[]  = {'C','I',0};
  91 static const WCHAR SDDL_OBJECT_INHERIT[]     = {'O','I',0};
  92 static const WCHAR SDDL_NO_PROPAGATE[]       = {'N','P',0};
  93 static const WCHAR SDDL_INHERIT_ONLY[]       = {'I','O',0};
  94 static const WCHAR SDDL_INHERITED[]          = {'I','D',0};
  95 static const WCHAR SDDL_AUDIT_SUCCESS[]      = {'S','A',0};
  96 static const WCHAR SDDL_AUDIT_FAILURE[]      = {'F','A',0};
  97
  98 /* set last error code from NT status and get the proper boolean return value */
  99 /* used for functions that are a simple wrapper around the corresponding ntdll API */
 100 static inline BOOL set_ntstatus( NTSTATUS status )
 101 {
 102     if (status) SetLastError( RtlNtStatusToDosError( status ));
 103     return !status;
 104 }
 105
 106 #define WINE_SIZE_OF_WORLD_ACCESS_ACL   (sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) + sizeof(sidWorld) - sizeof(DWORD))
 107
 108 static void GetWorldAccessACL(PACL pACL)
 109 {
 110     PACCESS_ALLOWED_ACE pACE = (PACCESS_ALLOWED_ACE) (pACL + 1);
 111
 112     pACL->AclRevision = ACL_REVISION;
 113     pACL->Sbz1 = 0;
 114     pACL->AclSize = WINE_SIZE_OF_WORLD_ACCESS_ACL;
 115     pACL->AceCount = 1;
 116     pACL->Sbz2 = 0;
 117
 118     pACE->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
 119     pACE->Header.AceFlags = CONTAINER_INHERIT_ACE;
 120     pACE->Header.AceSize = sizeof(ACCESS_ALLOWED_ACE) + sizeof(sidWorld) - sizeof(DWORD);
 121     pACE->Mask = 0xf3ffffff; /* Everything except reserved bits */
 122     memcpy(&pACE->SidStart, &sidWorld, sizeof(sidWorld));
 123 }
 124
 125 /************************************************************
 126  *                ADVAPI_IsLocalComputer
 127  *
 128  * Checks whether the server name indicates local machine.
 129  */
 130 static BOOL ADVAPI_IsLocalComputer(LPCWSTR ServerName)
 131 {
 132     DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
 133     BOOL Result;
 134     LPWSTR buf;
 135
 136     if (!ServerName || !ServerName[0])
 137         return TRUE;
 138
 139     buf = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
 140     Result = GetComputerNameW(buf,  &dwSize);
 141     if (Result && (ServerName[0] == '\\') && (ServerName[1] == '\\'))
 142         ServerName += 2;
 143     Result = Result && !lstrcmpW(ServerName, buf);
 144     HeapFree(GetProcessHeap(), 0, buf);
 145
 146     return Result;
 147 }
 148
 149 /*      ##############################
 150         ######  TOKEN FUNCTIONS ######
 151         ##############################
 152 */
 153
 154 /******************************************************************************
 155  * OpenProcessToken                     [ADVAPI32.@]
 156  * Opens the access token associated with a process handle.
 157  *
 158  * PARAMS
 159  *   ProcessHandle [I] Handle to process
 160  *   DesiredAccess [I] Desired access to process
 161  *   TokenHandle   [O] Pointer to handle of open access token
 162  *
 163  * RETURNS
 164  *  Success: TRUE. TokenHandle contains the access token.
 165  *  Failure: FALSE.
 166  *
 167  * NOTES
 168  *  See NtOpenProcessToken.
 169  */
 170 BOOL WINAPI
 171 OpenProcessToken( HANDLE ProcessHandle, DWORD DesiredAccess,
 172                   HANDLE *TokenHandle )
 173 {
 174         return set_ntstatus(NtOpenProcessToken( ProcessHandle, DesiredAccess, TokenHandle ));
 175 }
 176
 177 /******************************************************************************
 178  * OpenThreadToken [ADVAPI32.@]
 179  *
 180  * Opens the access token associated with a thread handle.
 181  *
 182  * PARAMS
 183  *   ThreadHandle  [I] Handle to process
 184  *   DesiredAccess [I] Desired access to the thread
 185  *   OpenAsSelf    [I] ???
 186  *   TokenHandle   [O] Destination for the token handle
 187  *
 188  * RETURNS
 189  *  Success: TRUE. TokenHandle contains the access token.
 190  *  Failure: FALSE.
 191  *
 192  * NOTES
 193  *  See NtOpenThreadToken.
 194  */
 195 BOOL WINAPI
 196 OpenThreadToken( HANDLE ThreadHandle, DWORD DesiredAccess,
 197                  BOOL OpenAsSelf, HANDLE *TokenHandle)
 198 {
 199         return set_ntstatus( NtOpenThreadToken(ThreadHandle, DesiredAccess, OpenAsSelf, TokenHandle));
 200 }
 201
 202 BOOL WINAPI
 203 AdjustTokenGroups( HANDLE TokenHandle, BOOL ResetToDefault, PTOKEN_GROUPS NewState,
 204                    DWORD BufferLength, PTOKEN_GROUPS PreviousState, PDWORD ReturnLength )
 205 {
 206     return set_ntstatus( NtAdjustGroupsToken(TokenHandle, ResetToDefault, NewState, BufferLength,
 207                                              PreviousState, ReturnLength));
 208 }
 209
 210 /******************************************************************************
 211  * AdjustTokenPrivileges [ADVAPI32.@]
 212  *
 213  * Adjust the privileges of an open token handle.
 214  *
 215  * PARAMS
 216  *  TokenHandle          [I]   Handle from OpenProcessToken() or OpenThreadToken()
 217  *  DisableAllPrivileges [I]   TRUE=Remove all privileges, FALSE=Use NewState
 218  *  NewState             [I]   Desired new privileges of the token
 219  *  BufferLength         [I]   Length of NewState
 220  *  PreviousState        [O]   Destination for the previous state
 221  *  ReturnLength         [I/O] Size of PreviousState
 222  *
 223  *
 224  * RETURNS
 225  *  Success: TRUE. Privileges are set to NewState and PreviousState is updated.
 226  *  Failure: FALSE.
 227  *
 228  * NOTES
 229  *  See NtAdjustPrivilegesToken.
 230  */
 231 BOOL WINAPI
 232 AdjustTokenPrivileges( HANDLE TokenHandle, BOOL DisableAllPrivileges,
 233                        LPVOID NewState, DWORD BufferLength,
 234                        LPVOID PreviousState, LPDWORD ReturnLength )
 235 {
 236     NTSTATUS status;
 237
 238     TRACE("\n");
 239
 240     status = NtAdjustPrivilegesToken(TokenHandle, DisableAllPrivileges,
 241                                                      NewState, BufferLength, PreviousState,
 242                                                      ReturnLength);
 243     SetLastError( RtlNtStatusToDosError( status ));
 244     if ((status == STATUS_SUCCESS) || (status == STATUS_NOT_ALL_ASSIGNED))
 245         return TRUE;
 246     else
 247         return FALSE;
 248 }
 249
 250 /******************************************************************************
 251  * CheckTokenMembership [ADVAPI32.@]
 252  *
 253  * Determine if an access token is a member of a SID.
 254  *
 255  * PARAMS
 256  *   TokenHandle [I] Handle from OpenProcessToken() or OpenThreadToken()
 257  *   SidToCheck  [I] SID that possibly contains the token
 258  *   IsMember    [O] Destination for result.
 259  *
 260  * RETURNS
 261  *  Success: TRUE. IsMember is TRUE if TokenHandle is a member, FALSE otherwise.
 262  *  Failure: FALSE.
 263  */
 264 BOOL WINAPI
 265 CheckTokenMembership( HANDLE TokenHandle, PSID SidToCheck,
 266                       PBOOL IsMember )
 267 {
 268   FIXME("(%p %p %p) stub!\n", TokenHandle, SidToCheck, IsMember);
 269
 270   *IsMember = TRUE;
 271   return(TRUE);
 272 }
 273
 274 /******************************************************************************
 275  * GetTokenInformation [ADVAPI32.@]
 276  *
 277  * Get a type of information about an access token.
 278  *
 279  * PARAMS
 280  *   token           [I] Handle from OpenProcessToken() or OpenThreadToken()
 281  *   tokeninfoclass  [I] A TOKEN_INFORMATION_CLASS from "winnt.h"
 282  *   tokeninfo       [O] Destination for token information
 283  *   tokeninfolength [I] Length of tokeninfo
 284  *   retlen          [O] Destination for returned token information length
 285  *
 286  * RETURNS
 287  *  Success: TRUE. tokeninfo contains retlen bytes of token information
 288  *  Failure: FALSE.
 289  *
 290  * NOTES
 291  *  See NtQueryInformationToken.
 292  */
 293 BOOL WINAPI
 294 GetTokenInformation( HANDLE token, TOKEN_INFORMATION_CLASS tokeninfoclass,
 295                      LPVOID tokeninfo, DWORD tokeninfolength, LPDWORD retlen )
 296 {
 297     TRACE("(%p, %s, %p, %ld, %p):\n",
 298           token,
 299           (tokeninfoclass == TokenUser) ? "TokenUser" :
 300           (tokeninfoclass == TokenGroups) ? "TokenGroups" :
 301           (tokeninfoclass == TokenPrivileges) ? "TokenPrivileges" :
 302           (tokeninfoclass == TokenOwner) ? "TokenOwner" :
 303           (tokeninfoclass == TokenPrimaryGroup) ? "TokenPrimaryGroup" :
 304           (tokeninfoclass == TokenDefaultDacl) ? "TokenDefaultDacl" :
 305           (tokeninfoclass == TokenSource) ? "TokenSource" :
 306           (tokeninfoclass == TokenType) ? "TokenType" :
 307           (tokeninfoclass == TokenImpersonationLevel) ? "TokenImpersonationLevel" :
 308           (tokeninfoclass == TokenStatistics) ? "TokenStatistics" :
 309           (tokeninfoclass == TokenRestrictedSids) ? "TokenRestrictedSids" :
 310           (tokeninfoclass == TokenSessionId) ? "TokenSessionId" :
 311           (tokeninfoclass == TokenGroupsAndPrivileges) ? "TokenGroupsAndPrivileges" :
 312           (tokeninfoclass == TokenSessionReference) ? "TokenSessionReference" :
 313           (tokeninfoclass == TokenSandBoxInert) ? "TokenSandBoxInert" :
 314           "Unknown",
 315           tokeninfo, tokeninfolength, retlen);
 316     return set_ntstatus( NtQueryInformationToken( token, tokeninfoclass, tokeninfo,
 317                                                   tokeninfolength, retlen));
 318 }
 319
 320 /******************************************************************************
 321  * SetTokenInformation [ADVAPI32.@]
 322  *
 323  * Set information for an access token.
 324  *
 325  * PARAMS
 326  *   token           [I] Handle from OpenProcessToken() or OpenThreadToken()
 327  *   tokeninfoclass  [I] A TOKEN_INFORMATION_CLASS from "winnt.h"
 328  *   tokeninfo       [I] Token information to set
 329  *   tokeninfolength [I] Length of tokeninfo
 330  *
 331  * RETURNS
 332  *  Success: TRUE. The information for the token is set to tokeninfo.
 333  *  Failure: FALSE.
 334  */
 335 BOOL WINAPI
 336 SetTokenInformation( HANDLE token, TOKEN_INFORMATION_CLASS tokeninfoclass,
 337                      LPVOID tokeninfo, DWORD tokeninfolength )
 338 {
 339     TRACE("(%p, %s, %p, %ld): stub\n",
 340           token,
 341           (tokeninfoclass == TokenUser) ? "TokenUser" :
 342           (tokeninfoclass == TokenGroups) ? "TokenGroups" :
 343           (tokeninfoclass == TokenPrivileges) ? "TokenPrivileges" :
 344           (tokeninfoclass == TokenOwner) ? "TokenOwner" :
 345           (tokeninfoclass == TokenPrimaryGroup) ? "TokenPrimaryGroup" :
 346           (tokeninfoclass == TokenDefaultDacl) ? "TokenDefaultDacl" :
 347           (tokeninfoclass == TokenSource) ? "TokenSource" :
 348           (tokeninfoclass == TokenType) ? "TokenType" :
 349           (tokeninfoclass == TokenImpersonationLevel) ? "TokenImpersonationLevel" :
 350           (tokeninfoclass == TokenStatistics) ? "TokenStatistics" :
 351           (tokeninfoclass == TokenRestrictedSids) ? "TokenRestrictedSids" :
 352           (tokeninfoclass == TokenSessionId) ? "TokenSessionId" :
 353           (tokeninfoclass == TokenGroupsAndPrivileges) ? "TokenGroupsAndPrivileges" :
 354           (tokeninfoclass == TokenSessionReference) ? "TokenSessionReference" :
 355           (tokeninfoclass == TokenSandBoxInert) ? "TokenSandBoxInert" :
 356           "Unknown",
 357           tokeninfo, tokeninfolength);
 358
 359     return set_ntstatus( NtSetInformationToken( token, tokeninfoclass, tokeninfo, tokeninfolength ));
 360 }
 361
 362 /*************************************************************************
 363  * SetThreadToken [ADVAPI32.@]
 364  *
 365  * Assigns an 'impersonation token' to a thread so it can assume the
 366  * security privileges of another thread or process.  Can also remove
 367  * a previously assigned token.
 368  *
 369  * PARAMS
 370  *   thread          [O] Handle to thread to set the token for
 371  *   token           [I] Token to set
 372  *
 373  * RETURNS
 374  *  Success: TRUE. The threads access token is set to token
 375  *  Failure: FALSE.
 376  *
 377  * NOTES
 378  *  Only supported on NT or higher. On Win9X this function does nothing.
 379  *  See SetTokenInformation.
 380  */
 381 BOOL WINAPI SetThreadToken(PHANDLE thread, HANDLE token)
 382 {
 383     return set_ntstatus( NtSetInformationThread( thread ? *thread : GetCurrentThread(),
 384                                                  ThreadImpersonationToken, &token, sizeof token ));
 385 }
 386
 387 /*      ##############################
 388         ######  SID FUNCTIONS   ######
 389         ##############################
 390 */
 391
 392 /******************************************************************************
 393  * AllocateAndInitializeSid [ADVAPI32.@]
 394  *
 395  * PARAMS
 396  *   pIdentifierAuthority []
 397  *   nSubAuthorityCount   []
 398  *   nSubAuthority0       []
 399  *   nSubAuthority1       []
 400  *   nSubAuthority2       []
 401  *   nSubAuthority3       []
 402  *   nSubAuthority4       []
 403  *   nSubAuthority5       []
 404  *   nSubAuthority6       []
 405  *   nSubAuthority7       []
 406  *   pSid                 []
 407  */
 408 BOOL WINAPI
 409 AllocateAndInitializeSid( PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
 410                           BYTE nSubAuthorityCount,
 411                           DWORD nSubAuthority0, DWORD nSubAuthority1,
 412                           DWORD nSubAuthority2, DWORD nSubAuthority3,
 413                           DWORD nSubAuthority4, DWORD nSubAuthority5,
 414                           DWORD nSubAuthority6, DWORD nSubAuthority7,
 415                           PSID *pSid )
 416 {
 417     return set_ntstatus( RtlAllocateAndInitializeSid(
 418                              pIdentifierAuthority, nSubAuthorityCount,
 419                              nSubAuthority0, nSubAuthority1, nSubAuthority2, nSubAuthority3,
 420                              nSubAuthority4, nSubAuthority5, nSubAuthority6, nSubAuthority7,
 421                              pSid ));
 422 }
 423
 424 /******************************************************************************
 425  * FreeSid [ADVAPI32.@]
 426  *
 427  * PARAMS
 428  *   pSid []
 429  */
 430 PVOID WINAPI
 431 FreeSid( PSID pSid )
 432 {
 433         RtlFreeSid(pSid);
 434         return NULL; /* is documented like this */
 435 }
 436
 437 /******************************************************************************
 438  * CopySid [ADVAPI32.@]
 439  *
 440  * PARAMS
 441  *   nDestinationSidLength []
 442  *   pDestinationSid       []
 443  *   pSourceSid            []
 444  */
 445 BOOL WINAPI
 446 CopySid( DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid )
 447 {
 448         return RtlCopySid(nDestinationSidLength, pDestinationSid, pSourceSid);
 449 }
 450
 451 BOOL WINAPI
 452 IsTokenRestricted( HANDLE TokenHandle )
 453 {
 454     TOKEN_GROUPS *groups;
 455     DWORD size;
 456     NTSTATUS status;
 457     BOOL restricted;
 458
 459     TRACE("(%p)\n", TokenHandle);
 460
 461     status = NtQueryInformationToken(TokenHandle, TokenRestrictedSids, NULL, 0, &size);
 462     if (status != STATUS_BUFFER_TOO_SMALL)
 463         return FALSE;
 464
 465     groups = HeapAlloc(GetProcessHeap(), 0, size);
 466     if (!groups)
 467     {
 468         SetLastError(ERROR_OUTOFMEMORY);
 469         return FALSE;
 470     }
 471
 472     status = NtQueryInformationToken(TokenHandle, TokenRestrictedSids, groups, size, &size);
 473     if (status != STATUS_SUCCESS)
 474     {
 475         HeapFree(GetProcessHeap(), 0, groups);
 476         return set_ntstatus(status);
 477     }
 478
 479     if (groups->GroupCount)
 480         restricted = TRUE;
 481     else
 482         restricted = FALSE;
 483
 484     HeapFree(GetProcessHeap(), 0, groups);
 485
 486     return restricted;
 487 }
 488
 489 /******************************************************************************
 490  * IsValidSid [ADVAPI32.@]
 491  *
 492  * PARAMS
 493  *   pSid []
 494  */
 495 BOOL WINAPI
 496 IsValidSid( PSID pSid )
 497 {
 498         return RtlValidSid( pSid );
 499 }
 500
 501 /******************************************************************************
 502  * EqualSid [ADVAPI32.@]
 503  *
 504  * PARAMS
 505  *   pSid1 []
 506  *   pSid2 []
 507  */
 508 BOOL WINAPI
 509 EqualSid( PSID pSid1, PSID pSid2 )
 510 {
 511         return RtlEqualSid( pSid1, pSid2 );
 512 }
 513
 514 /******************************************************************************
 515  * EqualPrefixSid [ADVAPI32.@]
 516  */
 517 BOOL WINAPI EqualPrefixSid (PSID pSid1, PSID pSid2)
 518 {
 519         return RtlEqualPrefixSid(pSid1, pSid2);
 520 }
 521
 522 /******************************************************************************
 523  * GetSidLengthRequired [ADVAPI32.@]
 524  *
 525  * PARAMS
 526  *   nSubAuthorityCount []
 527  */
 528 DWORD WINAPI
 529 GetSidLengthRequired( BYTE nSubAuthorityCount )
 530 {
 531         return RtlLengthRequiredSid(nSubAuthorityCount);
 532 }
 533
 534 /******************************************************************************
 535  * InitializeSid [ADVAPI32.@]
 536  *
 537  * PARAMS
 538  *   pIdentifierAuthority []
 539  */
 540 BOOL WINAPI
 541 InitializeSid (
 542         PSID pSid,
 543         PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
 544         BYTE nSubAuthorityCount)
 545 {
 546         return RtlInitializeSid(pSid, pIdentifierAuthority, nSubAuthorityCount);
 547 }
 548
 549 DWORD WINAPI
 550 GetEffectiveRightsFromAclA( PACL pacl, PTRUSTEEA pTrustee, PACCESS_MASK pAccessRights )
 551 {
 552     FIXME("%p %p %p - stub\n", pacl, pTrustee, pAccessRights);
 553
 554     return 1;
 555 }
 556
 557 DWORD WINAPI
 558 GetEffectiveRightsFromAclW( PACL pacl, PTRUSTEEW pTrustee, PACCESS_MASK pAccessRights )
 559 {
 560     FIXME("%p %p %p - stub\n", pacl, pTrustee, pAccessRights);
 561
 562     return 1;
 563 }
 564
 565 /******************************************************************************
 566  * GetSidIdentifierAuthority [ADVAPI32.@]
 567  *
 568  * PARAMS
 569  *   pSid []
 570  */
 571 PSID_IDENTIFIER_AUTHORITY WINAPI
 572 GetSidIdentifierAuthority( PSID pSid )
 573 {
 574         return RtlIdentifierAuthoritySid(pSid);
 575 }
 576
 577 /******************************************************************************
 578  * GetSidSubAuthority [ADVAPI32.@]
 579  *
 580  * PARAMS
 581  *   pSid          []
 582  *   nSubAuthority []
 583  */
 584 PDWORD WINAPI
 585 GetSidSubAuthority( PSID pSid, DWORD nSubAuthority )
 586 {
 587         return RtlSubAuthoritySid(pSid, nSubAuthority);
 588 }
 589
 590 /******************************************************************************
 591  * GetSidSubAuthorityCount [ADVAPI32.@]
 592  *
 593  * PARAMS
 594  *   pSid []
 595  */
 596 PUCHAR WINAPI
 597 GetSidSubAuthorityCount (PSID pSid)
 598 {
 599         return RtlSubAuthorityCountSid(pSid);
 600 }
 601
 602 /******************************************************************************
 603  * GetLengthSid [ADVAPI32.@]
 604  *
 605  * PARAMS
 606  *   pSid []
 607  */
 608 DWORD WINAPI
 609 GetLengthSid (PSID pSid)
 610 {
 611         return RtlLengthSid(pSid);
 612 }
 613
 614 /*      ##############################################
 615         ######  SECURITY DESCRIPTOR FUNCTIONS   ######
 616         ##############################################
 617 */
 618
 619  /******************************************************************************
 620  * BuildSecurityDescriptorA [ADVAPI32.@]
 621  *
 622  * Builds a SD from
 623  *
 624  * PARAMS
 625  *  pOwner                [I]
 626  *  pGroup                [I]
 627  *  cCountOfAccessEntries [I]
 628  *  pListOfAccessEntries  [I]
 629  *  cCountOfAuditEntries  [I]
 630  *  pListofAuditEntries   [I]
 631  *  pOldSD                [I]
 632  *  lpdwBufferLength      [I/O]
 633  *  pNewSD                [O]
 634  *
 635  * RETURNS
 636  *  Success: ERROR_SUCCESS
 637  *  Failure: nonzero error code from Winerror.h
 638  */
 639 DWORD WINAPI BuildSecurityDescriptorA(
 640     IN PTRUSTEE_A pOwner,
 641     IN PTRUSTEE_A pGroup,
 642     IN DWORD cCountOfAccessEntries,
 643     IN PEXPLICIT_ACCESS_A pListOfAccessEntries,
 644     IN DWORD cCountOfAuditEntries,
 645     IN PEXPLICIT_ACCESS_A pListofAuditEntries,
 646     IN PSECURITY_DESCRIPTOR pOldSD,
 647     IN OUT PDWORD lpdwBufferLength,
 648     OUT PSECURITY_DESCRIPTOR pNewSD)
 649 {
 650     FIXME("(%p,%p,%ld,%p,%ld,%p,%p,%p,%p) stub!\n",pOwner,pGroup,
 651           cCountOfAccessEntries,pListOfAccessEntries,cCountOfAuditEntries,
 652           pListofAuditEntries,pOldSD,lpdwBufferLength,pNewSD);
 653
 654     return ERROR_CALL_NOT_IMPLEMENTED;
 655 }
 656
 657 /******************************************************************************
 658  * BuildSecurityDescriptorW [ADVAPI32.@]
 659  *
 660  * See BuildSecurityDescriptorA.
 661  */
 662 DWORD WINAPI BuildSecurityDescriptorW(
 663     IN PTRUSTEE_W pOwner,
 664     IN PTRUSTEE_W pGroup,
 665     IN DWORD cCountOfAccessEntries,
 666     IN PEXPLICIT_ACCESS_W pListOfAccessEntries,
 667     IN DWORD cCountOfAuditEntries,
 668     IN PEXPLICIT_ACCESS_W pListofAuditEntries,
 669     IN PSECURITY_DESCRIPTOR pOldSD,
 670     IN OUT PDWORD lpdwBufferLength,
 671     OUT PSECURITY_DESCRIPTOR pNewSD)
 672 {
 673     FIXME("(%p,%p,%ld,%p,%ld,%p,%p,%p,%p) stub!\n",pOwner,pGroup,
 674           cCountOfAccessEntries,pListOfAccessEntries,cCountOfAuditEntries,
 675           pListofAuditEntries,pOldSD,lpdwBufferLength,pNewSD);
 676
 677     return ERROR_CALL_NOT_IMPLEMENTED;
 678 }
 679
 680 /******************************************************************************
 681  * InitializeSecurityDescriptor [ADVAPI32.@]
 682  *
 683  * PARAMS
 684  *   pDescr   []
 685  *   revision []
 686  */
 687 BOOL WINAPI
 688 InitializeSecurityDescriptor( PSECURITY_DESCRIPTOR pDescr, DWORD revision )
 689 {
 690         return set_ntstatus( RtlCreateSecurityDescriptor(pDescr, revision ));
 691 }
 692
 693
 694 /******************************************************************************
 695  * MakeAbsoluteSD [ADVAPI32.@]
 696  */
 697 BOOL WINAPI MakeAbsoluteSD (
 698         IN PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
 699         OUT PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
 700         OUT LPDWORD lpdwAbsoluteSecurityDescriptorSize,
 701         OUT PACL pDacl,
 702         OUT LPDWORD lpdwDaclSize,
 703         OUT PACL pSacl,
 704         OUT LPDWORD lpdwSaclSize,
 705         OUT PSID pOwner,
 706         OUT LPDWORD lpdwOwnerSize,
 707         OUT PSID pPrimaryGroup,
 708         OUT LPDWORD lpdwPrimaryGroupSize)
 709 {
 710     return set_ntstatus( RtlSelfRelativeToAbsoluteSD(pSelfRelativeSecurityDescriptor,
 711                                                      pAbsoluteSecurityDescriptor,
 712                                                      lpdwAbsoluteSecurityDescriptorSize,
 713                                                      pDacl, lpdwDaclSize, pSacl, lpdwSaclSize,
 714                                                      pOwner, lpdwOwnerSize,
 715                                                      pPrimaryGroup, lpdwPrimaryGroupSize));
 716 }
 717
 718 /******************************************************************************
 719  * GetKernelObjectSecurity [ADVAPI32.@]
 720  */
 721 BOOL WINAPI GetKernelObjectSecurity(
 722         HANDLE Handle,
 723         SECURITY_INFORMATION RequestedInformation,
 724         PSECURITY_DESCRIPTOR pSecurityDescriptor,
 725         DWORD nLength,
 726         LPDWORD lpnLengthNeeded )
 727 {
 728     TRACE("(%p,0x%08lx,%p,0x%08lx,%p)\n", Handle, RequestedInformation,
 729           pSecurityDescriptor, nLength, lpnLengthNeeded);
 730
 731     return set_ntstatus( NtQuerySecurityObject(Handle, RequestedInformation, pSecurityDescriptor,
 732                                                nLength, lpnLengthNeeded ));
 733 }
 734
 735 /******************************************************************************
 736  * GetPrivateObjectSecurity [ADVAPI32.@]
 737  */
 738 BOOL WINAPI GetPrivateObjectSecurity(
 739         PSECURITY_DESCRIPTOR ObjectDescriptor,
 740         SECURITY_INFORMATION SecurityInformation,
 741         PSECURITY_DESCRIPTOR ResultantDescriptor,
 742         DWORD DescriptorLength,
 743         PDWORD ReturnLength )
 744 {
 745     TRACE("(%p,0x%08lx,%p,0x%08lx,%p)\n", ObjectDescriptor, SecurityInformation,
 746           ResultantDescriptor, DescriptorLength, ReturnLength);
 747
 748     return set_ntstatus( NtQuerySecurityObject(ObjectDescriptor, SecurityInformation,
 749                                                ResultantDescriptor, DescriptorLength, ReturnLength ));
 750 }
 751
 752 /******************************************************************************
 753  * GetSecurityDescriptorLength [ADVAPI32.@]
 754  */
 755 DWORD WINAPI GetSecurityDescriptorLength( PSECURITY_DESCRIPTOR pDescr)
 756 {
 757         return RtlLengthSecurityDescriptor(pDescr);
 758 }
 759
 760 /******************************************************************************
 761  * GetSecurityDescriptorOwner [ADVAPI32.@]
 762  *
 763  * PARAMS
 764  *   pOwner            []
 765  *   lpbOwnerDefaulted []
 766  */
 767 BOOL WINAPI
 768 GetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pDescr, PSID *pOwner,
 769                             LPBOOL lpbOwnerDefaulted )
 770 {
 771     BOOLEAN defaulted;
 772     BOOL ret = set_ntstatus( RtlGetOwnerSecurityDescriptor( pDescr, pOwner, &defaulted ));
 773     *lpbOwnerDefaulted = defaulted;
 774     return ret;
 775 }
 776
 777 /******************************************************************************
 778  * SetSecurityDescriptorOwner [ADVAPI32.@]
 779  *
 780  * PARAMS
 781  */
 782 BOOL WINAPI SetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor,
 783                                    PSID pOwner, BOOL bOwnerDefaulted)
 784 {
 785     return set_ntstatus( RtlSetOwnerSecurityDescriptor(pSecurityDescriptor, pOwner, bOwnerDefaulted));
 786 }
 787 /******************************************************************************
 788  * GetSecurityDescriptorGroup                   [ADVAPI32.@]
 789  */
 790 BOOL WINAPI GetSecurityDescriptorGroup(
 791         PSECURITY_DESCRIPTOR SecurityDescriptor,
 792         PSID *Group,
 793         LPBOOL GroupDefaulted)
 794 {
 795     BOOLEAN defaulted;
 796     BOOL ret = set_ntstatus( RtlGetGroupSecurityDescriptor(SecurityDescriptor, Group, &defaulted ));
 797     *GroupDefaulted = defaulted;
 798     return ret;
 799 }
 800 /******************************************************************************
 801  * SetSecurityDescriptorGroup [ADVAPI32.@]
 802  */
 803 BOOL WINAPI SetSecurityDescriptorGroup ( PSECURITY_DESCRIPTOR SecurityDescriptor,
 804                                            PSID Group, BOOL GroupDefaulted)
 805 {
 806     return set_ntstatus( RtlSetGroupSecurityDescriptor( SecurityDescriptor, Group, GroupDefaulted));
 807 }
 808
 809 /******************************************************************************
 810  * IsValidSecurityDescriptor [ADVAPI32.@]
 811  *
 812  * PARAMS
 813  *   lpsecdesc []
 814  */
 815 BOOL WINAPI
 816 IsValidSecurityDescriptor( PSECURITY_DESCRIPTOR SecurityDescriptor )
 817 {
 818     return set_ntstatus( RtlValidSecurityDescriptor(SecurityDescriptor));
 819 }
 820
 821 /******************************************************************************
 822  *  GetSecurityDescriptorDacl                   [ADVAPI32.@]
 823  */
 824 BOOL WINAPI GetSecurityDescriptorDacl(
 825         IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 826         OUT LPBOOL lpbDaclPresent,
 827         OUT PACL *pDacl,
 828         OUT LPBOOL lpbDaclDefaulted)
 829 {
 830     BOOLEAN present, defaulted;
 831     BOOL ret = set_ntstatus( RtlGetDaclSecurityDescriptor(pSecurityDescriptor, &present, pDacl, &defaulted));
 832     *lpbDaclPresent = present;
 833     *lpbDaclDefaulted = defaulted;
 834     return ret;
 835 }
 836
 837 /******************************************************************************
 838  *  SetSecurityDescriptorDacl                   [ADVAPI32.@]
 839  */
 840 BOOL WINAPI
 841 SetSecurityDescriptorDacl (
 842         PSECURITY_DESCRIPTOR lpsd,
 843         BOOL daclpresent,
 844         PACL dacl,
 845         BOOL dacldefaulted )
 846 {
 847     return set_ntstatus( RtlSetDaclSecurityDescriptor (lpsd, daclpresent, dacl, dacldefaulted ) );
 848 }
 849 /******************************************************************************
 850  *  GetSecurityDescriptorSacl                   [ADVAPI32.@]
 851  */
 852 BOOL WINAPI GetSecurityDescriptorSacl(
 853         IN PSECURITY_DESCRIPTOR lpsd,
 854         OUT LPBOOL lpbSaclPresent,
 855         OUT PACL *pSacl,
 856         OUT LPBOOL lpbSaclDefaulted)
 857 {
 858     BOOLEAN present, defaulted;
 859     BOOL ret = set_ntstatus( RtlGetSaclSecurityDescriptor(lpsd, &present, pSacl, &defaulted) );
 860     *lpbSaclPresent = present;
 861     *lpbSaclDefaulted = defaulted;
 862     return ret;
 863 }
 864
 865 /**************************************************************************
 866  * SetSecurityDescriptorSacl                    [ADVAPI32.@]
 867  */
 868 BOOL WINAPI SetSecurityDescriptorSacl (
 869         PSECURITY_DESCRIPTOR lpsd,
 870         BOOL saclpresent,
 871         PACL lpsacl,
 872         BOOL sacldefaulted)
 873 {
 874     return set_ntstatus (RtlSetSaclSecurityDescriptor(lpsd, saclpresent, lpsacl, sacldefaulted));
 875 }
 876 /******************************************************************************
 877  * MakeSelfRelativeSD [ADVAPI32.@]
 878  *
 879  * PARAMS
 880  *   lpabssecdesc  []
 881  *   lpselfsecdesc []
 882  *   lpbuflen      []
 883  */
 884 BOOL WINAPI
 885 MakeSelfRelativeSD(
 886         IN PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
 887         IN PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
 888         IN OUT LPDWORD lpdwBufferLength)
 889 {
 890     return set_ntstatus( RtlMakeSelfRelativeSD( pAbsoluteSecurityDescriptor,
 891                                                 pSelfRelativeSecurityDescriptor, lpdwBufferLength));
 892 }
 893
 894 /******************************************************************************
 895  * GetSecurityDescriptorControl                 [ADVAPI32.@]
 896  */
 897
 898 BOOL WINAPI GetSecurityDescriptorControl ( PSECURITY_DESCRIPTOR  pSecurityDescriptor,
 899                  PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision)
 900 {
 901     return set_ntstatus( RtlGetControlSecurityDescriptor(pSecurityDescriptor,pControl,lpdwRevision));
 902 }
 903
 904 /*      ##############################
 905         ######  ACL FUNCTIONS   ######
 906         ##############################
 907 */
 908
 909 /*************************************************************************
 910  * InitializeAcl [ADVAPI32.@]
 911  */
 912 BOOL WINAPI InitializeAcl(PACL acl, DWORD size, DWORD rev)
 913 {
 914     return set_ntstatus( RtlCreateAcl(acl, size, rev));
 915 }
 916
 917 BOOL WINAPI ImpersonateNamedPipeClient( HANDLE hNamedPipe )
 918 {
 919     TRACE("(%p)\n", hNamedPipe);
 920
 921     return set_ntstatus( NtFsControlFile(hNamedPipe, NULL, NULL, NULL, NULL,
 922                          FSCTL_PIPE_IMPERSONATE, NULL, 0, NULL, 0) );
 923 }
 924
 925 /******************************************************************************
 926  *  AddAccessAllowedAce [ADVAPI32.@]
 927  */
 928 BOOL WINAPI AddAccessAllowedAce(
 929         IN OUT PACL pAcl,
 930         IN DWORD dwAceRevision,
 931         IN DWORD AccessMask,
 932         IN PSID pSid)
 933 {
 934     return set_ntstatus(RtlAddAccessAllowedAce(pAcl, dwAceRevision, AccessMask, pSid));
 935 }
 936
 937 /******************************************************************************
 938  *  AddAccessAllowedAceEx [ADVAPI32.@]
 939  */
 940 BOOL WINAPI AddAccessAllowedAceEx(
 941         IN OUT PACL pAcl,
 942         IN DWORD dwAceRevision,
 943         IN DWORD AceFlags,
 944         IN DWORD AccessMask,
 945         IN PSID pSid)
 946 {
 947     return set_ntstatus(RtlAddAccessAllowedAceEx(pAcl, dwAceRevision, AceFlags, AccessMask, pSid));
 948 }
 949
 950 /******************************************************************************
 951  *  AddAccessDeniedAce [ADVAPI32.@]
 952  */
 953 BOOL WINAPI AddAccessDeniedAce(
 954         IN OUT PACL pAcl,
 955         IN DWORD dwAceRevision,
 956         IN DWORD AccessMask,
 957         IN PSID pSid)
 958 {
 959     return set_ntstatus(RtlAddAccessDeniedAce(pAcl, dwAceRevision, AccessMask, pSid));
 960 }
 961
 962 /******************************************************************************
 963  *  AddAccessDeniedAceEx [ADVAPI32.@]
 964  */
 965 BOOL WINAPI AddAccessDeniedAceEx(
 966         IN OUT PACL pAcl,
 967         IN DWORD dwAceRevision,
 968         IN DWORD AceFlags,
 969         IN DWORD AccessMask,
 970         IN PSID pSid)
 971 {
 972     return set_ntstatus(RtlAddAccessDeniedAceEx(pAcl, dwAceRevision, AceFlags, AccessMask, pSid));
 973 }
 974
 975 /******************************************************************************
 976  *  AddAce [ADVAPI32.@]
 977  */
 978 BOOL WINAPI AddAce(
 979         IN OUT PACL pAcl,
 980         IN DWORD dwAceRevision,
 981         IN DWORD dwStartingAceIndex,
 982         LPVOID pAceList,
 983         DWORD nAceListLength)
 984 {
 985     return set_ntstatus(RtlAddAce(pAcl, dwAceRevision, dwStartingAceIndex, pAceList, nAceListLength));
 986 }
 987
 988 /******************************************************************************
 989  * DeleteAce [ADVAPI32.@]
 990  */
 991 BOOL WINAPI DeleteAce(PACL pAcl, DWORD dwAceIndex)
 992 {
 993     return set_ntstatus(RtlDeleteAce(pAcl, dwAceIndex));
 994 }
 995
 996 /******************************************************************************
 997  *  FindFirstFreeAce [ADVAPI32.@]
 998  */
 999 BOOL WINAPI FindFirstFreeAce(IN PACL pAcl, LPVOID * pAce)
1000 {
1001         return RtlFirstFreeAce(pAcl, (PACE_HEADER *)pAce);
1002 }
1003
1004 /******************************************************************************
1005  * GetAce [ADVAPI32.@]
1006  */
1007 BOOL WINAPI GetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce )
1008 {
1009     return set_ntstatus(RtlGetAce(pAcl, dwAceIndex, pAce));
1010 }
1011
1012 /******************************************************************************
1013  * GetAclInformation [ADVAPI32.@]
1014  */
1015 BOOL WINAPI GetAclInformation(
1016   PACL pAcl,
1017   LPVOID pAclInformation,
1018   DWORD nAclInformationLength,
1019   ACL_INFORMATION_CLASS dwAclInformationClass)
1020 {
1021     return set_ntstatus(RtlQueryInformationAcl(pAcl, pAclInformation,
1022                                                nAclInformationLength, dwAclInformationClass));
1023 }
1024
1025 /******************************************************************************
1026  *  IsValidAcl [ADVAPI32.@]
1027  */
1028 BOOL WINAPI IsValidAcl(IN PACL pAcl)
1029 {
1030         return RtlValidAcl(pAcl);
1031 }
1032
1033 /*      ##############################
1034         ######  MISC FUNCTIONS  ######
1035         ##############################
1036 */
1037
1038 /******************************************************************************
1039  * AllocateLocallyUniqueId [ADVAPI32.@]
1040  *
1041  * PARAMS
1042  *   lpLuid []
1043  */
1044 BOOL WINAPI AllocateLocallyUniqueId( PLUID lpLuid )
1045 {
1046     return set_ntstatus(NtAllocateLocallyUniqueId(lpLuid));
1047 }
1048
1049 static const WCHAR SE_CREATE_TOKEN_NAME_W[] =
1050  { 'S','e','C','r','e','a','t','e','T','o','k','e','n','P','r','i','v','i','l','e','g','e',0 };
1051 static const WCHAR SE_ASSIGNPRIMARYTOKEN_NAME_W[] =
1052  { 'S','e','A','s','s','i','g','n','P','r','i','m','a','r','y','T','o','k','e','n','P','r','i','v','i','l','e','g','e',0 };
1053 static const WCHAR SE_LOCK_MEMORY_NAME_W[] =
1054  { 'S','e','L','o','c','k','M','e','m','o','r','y','P','r','i','v','i','l','e','g','e',0 };
1055 static const WCHAR SE_INCREASE_QUOTA_NAME_W[] =
1056  { 'S','e','I','n','c','r','e','a','s','e','Q','u','o','t','a','P','r','i','v','i','l','e','g','e',0 };
1057 static const WCHAR SE_MACHINE_ACCOUNT_NAME_W[] =
1058  { 'S','e','M','a','c','h','i','n','e','A','c','c','o','u','n','t','P','r','i','v','i','l','e','g','e',0 };
1059 static const WCHAR SE_TCB_NAME_W[] =
1060  { 'S','e','T','c','b','P','r','i','v','i','l','e','g','e',0 };
1061 static const WCHAR SE_SECURITY_NAME_W[] =
1062  { 'S','e','S','e','c','u','r','i','t','y','P','r','i','v','i','l','e','g','e',0 };
1063 static const WCHAR SE_TAKE_OWNERSHIP_NAME_W[] =
1064  { 'S','e','T','a','k','e','O','w','n','e','r','s','h','i','p','P','r','i','v','i','l','e','g','e',0 };
1065 static const WCHAR SE_LOAD_DRIVER_NAME_W[] =
1066  { 'S','e','L','o','a','d','D','r','i','v','e','r','P','r','i','v','i','l','e','g','e',0 };
1067 static const WCHAR SE_SYSTEM_PROFILE_NAME_W[] =
1068  { 'S','e','S','y','s','t','e','m','P','r','o','f','i','l','e','P','r','i','v','i','l','e','g','e',0 };
1069 static const WCHAR SE_SYSTEMTIME_NAME_W[] =
1070  { 'S','e','S','y','s','t','e','m','t','i','m','e','P','r','i','v','i','l','e','g','e',0 };
1071 static const WCHAR SE_PROF_SINGLE_PROCESS_NAME_W[] =
1072  { 'S','e','P','r','o','f','i','l','e','S','i','n','g','l','e','P','r','o','c','e','s','s','P','r','i','v','i','l','e','g','e',0 };
1073 static const WCHAR SE_INC_BASE_PRIORITY_NAME_W[] =
1074  { 'S','e','I','n','c','r','e','a','s','e','B','a','s','e','P','r','i','o','r','i','t','y','P','r','i','v','i','l','e','g','e',0 };
1075 static const WCHAR SE_CREATE_PAGEFILE_NAME_W[] =
1076  { 'S','e','C','r','e','a','t','e','P','a','g','e','f','i','l','e','P','r','i','v','i','l','e','g','e',0 };
1077 static const WCHAR SE_CREATE_PERMANENT_NAME_W[] =
1078  { 'S','e','C','r','e','a','t','e','P','e','r','m','a','n','e','n','t','P','r','i','v','i','l','e','g','e',0 };
1079 static const WCHAR SE_BACKUP_NAME_W[] =
1080  { 'S','e','B','a','c','k','u','p','P','r','i','v','i','l','e','g','e',0 };
1081 static const WCHAR SE_RESTORE_NAME_W[] =
1082  { 'S','e','R','e','s','t','o','r','e','P','r','i','v','i','l','e','g','e',0 };
1083 static const WCHAR SE_SHUTDOWN_NAME_W[] =
1084  { 'S','e','S','h','u','t','d','o','w','n','P','r','i','v','i','l','e','g','e',0 };
1085 static const WCHAR SE_DEBUG_NAME_W[] =
1086  { 'S','e','D','e','b','u','g','P','r','i','v','i','l','e','g','e',0 };
1087 static const WCHAR SE_AUDIT_NAME_W[] =
1088  { 'S','e','A','u','d','i','t','P','r','i','v','i','l','e','g','e',0 };
1089 static const WCHAR SE_SYSTEM_ENVIRONMENT_NAME_W[] =
1090  { 'S','e','S','y','s','t','e','m','E','n','v','i','r','o','n','m','e','n','t','P','r','i','v','i','l','e','g','e',0 };
1091 static const WCHAR SE_CHANGE_NOTIFY_NAME_W[] =
1092  { 'S','e','C','h','a','n','g','e','N','o','t','i','f','y','P','r','i','v','i','l','e','g','e',0 };
1093 static const WCHAR SE_REMOTE_SHUTDOWN_NAME_W[] =
1094  { 'S','e','R','e','m','o','t','e','S','h','u','t','d','o','w','n','P','r','i','v','i','l','e','g','e',0 };
1095 static const WCHAR SE_UNDOCK_NAME_W[] =
1096  { 'S','e','U','n','d','o','c','k','P','r','i','v','i','l','e','g','e',0 };
1097 static const WCHAR SE_SYNC_AGENT_NAME_W[] =
1098  { 'S','e','S','y','n','c','A','g','e','n','t','P','r','i','v','i','l','e','g','e',0 };
1099 static const WCHAR SE_ENABLE_DELEGATION_NAME_W[] =
1100  { 'S','e','E','n','a','b','l','e','D','e','l','e','g','a','t','i','o','n','P','r','i','v','i','l','e','g','e',0 };
1101 static const WCHAR SE_MANAGE_VOLUME_NAME_W[] =
1102  { 'S','e','M','a','n','a','g','e','V','o','l','u','m','e','P','r','i','v','i','l','e','g','e',0 };
1103 static const WCHAR SE_IMPERSONATE_NAME_W[] =
1104  { 'S','e','I','m','p','e','r','s','o','n','a','t','e','P','r','i','v','i','l','e','g','e',0 };
1105 static const WCHAR SE_CREATE_GLOBAL_NAME_W[] =
1106  { 'S','e','C','r','e','a','t','e','G','l','o','b','a','l','P','r','i','v','i','l','e','g','e',0 };
1107
1108 static const WCHAR * const WellKnownPrivNames[SE_MAX_WELL_KNOWN_PRIVILEGE + 1] =
1109 {
1110     NULL,
1111     NULL,
1112     SE_CREATE_TOKEN_NAME_W,
1113     SE_ASSIGNPRIMARYTOKEN_NAME_W,
1114     SE_LOCK_MEMORY_NAME_W,
1115     SE_INCREASE_QUOTA_NAME_W,
1116     SE_MACHINE_ACCOUNT_NAME_W,
1117     SE_TCB_NAME_W,
1118     SE_SECURITY_NAME_W,
1119     SE_TAKE_OWNERSHIP_NAME_W,
1120     SE_LOAD_DRIVER_NAME_W,
1121     SE_SYSTEM_PROFILE_NAME_W,
1122     SE_SYSTEMTIME_NAME_W,
1123     SE_PROF_SINGLE_PROCESS_NAME_W,
1124     SE_INC_BASE_PRIORITY_NAME_W,
1125     SE_CREATE_PAGEFILE_NAME_W,
1126     SE_CREATE_PERMANENT_NAME_W,
1127     SE_BACKUP_NAME_W,
1128     SE_RESTORE_NAME_W,
1129     SE_SHUTDOWN_NAME_W,
1130     SE_DEBUG_NAME_W,
1131     SE_AUDIT_NAME_W,
1132     SE_SYSTEM_ENVIRONMENT_NAME_W,
1133     SE_CHANGE_NOTIFY_NAME_W,
1134     SE_REMOTE_SHUTDOWN_NAME_W,
1135     SE_UNDOCK_NAME_W,
1136     SE_SYNC_AGENT_NAME_W,
1137     SE_ENABLE_DELEGATION_NAME_W,
1138     SE_MANAGE_VOLUME_NAME_W,
1139     SE_IMPERSONATE_NAME_W,
1140     SE_CREATE_GLOBAL_NAME_W,
1141 };
1142
1143 /******************************************************************************
1144  * LookupPrivilegeValueW                        [ADVAPI32.@]
1145  *
1146  * See LookupPrivilegeValueA.
1147  */
1148 BOOL WINAPI
1149 LookupPrivilegeValueW( LPCWSTR lpSystemName, LPCWSTR lpName, PLUID lpLuid )
1150 {
1151     UINT i;
1152
1153     TRACE("%s,%s,%p\n",debugstr_w(lpSystemName), debugstr_w(lpName), lpLuid);
1154
1155     if (!ADVAPI_IsLocalComputer(lpSystemName))
1156     {
1157         SetLastError(RPC_S_SERVER_UNAVAILABLE);
1158         return FALSE;
1159     }
1160     if (!lpName)
1161     {
1162         SetLastError(ERROR_NO_SUCH_PRIVILEGE);
1163         return FALSE;
1164     }
1165     for( i=SE_MIN_WELL_KNOWN_PRIVILEGE; i<SE_MAX_WELL_KNOWN_PRIVILEGE; i++ )
1166     {
1167         if( !WellKnownPrivNames[i] )
1168             continue;
1169         if( strcmpiW( WellKnownPrivNames[i], lpName) )
1170             continue;
1171         lpLuid->LowPart = i;
1172         lpLuid->HighPart = 0;
1173         TRACE( "%s -> %08lx-%08lx\n",debugstr_w( lpSystemName ),
1174                lpLuid->HighPart, lpLuid->LowPart );
1175         return TRUE;
1176     }
1177     SetLastError(ERROR_NO_SUCH_PRIVILEGE);
1178     return FALSE;
1179 }
1180
1181 /******************************************************************************
1182  * LookupPrivilegeValueA                        [ADVAPI32.@]
1183  *
1184  * Retrieves LUID used on a system to represent the privilege name.
1185  *
1186  * PARAMS
1187  *  lpSystemName [I] Name of the system
1188  *  lpName       [I] Name of the privilege
1189  *  lpLuid       [O] Destination for the resulting LUID
1190  *
1191  * RETURNS
1192  *  Success: TRUE. lpLuid contains the requested LUID.
1193  *  Failure: FALSE.
1194  */
1195 BOOL WINAPI
1196 LookupPrivilegeValueA( LPCSTR lpSystemName, LPCSTR lpName, PLUID lpLuid )
1197 {
1198     UNICODE_STRING lpSystemNameW;
1199     UNICODE_STRING lpNameW;
1200     BOOL ret;
1201
1202     RtlCreateUnicodeStringFromAsciiz(&lpSystemNameW, lpSystemName);
1203     RtlCreateUnicodeStringFromAsciiz(&lpNameW,lpName);
1204     ret = LookupPrivilegeValueW(lpSystemNameW.Buffer, lpNameW.Buffer, lpLuid);
1205     RtlFreeUnicodeString(&lpNameW);
1206     RtlFreeUnicodeString(&lpSystemNameW);
1207     return ret;
1208 }
1209
1210 BOOL WINAPI LookupPrivilegeDisplayNameA( LPCSTR lpSystemName, LPCSTR lpName, LPSTR lpDisplayName,
1211                                          LPDWORD cchDisplayName, LPDWORD lpLanguageId )
1212 {
1213     FIXME("%s %s %s %p %p - stub\n", debugstr_a(lpSystemName), debugstr_a(lpName),
1214           debugstr_a(lpDisplayName), cchDisplayName, lpLanguageId);
1215
1216     return FALSE;
1217 }
1218
1219 BOOL WINAPI LookupPrivilegeDisplayNameW( LPCWSTR lpSystemName, LPCWSTR lpName, LPWSTR lpDisplayName,
1220                                          LPDWORD cchDisplayName, LPDWORD lpLanguageId )
1221 {
1222     FIXME("%s %s %s %p %p - stub\n", debugstr_w(lpSystemName), debugstr_w(lpName),
1223           debugstr_w(lpDisplayName), cchDisplayName, lpLanguageId);
1224
1225     return FALSE;
1226 }
1227
1228 /******************************************************************************
1229  * LookupPrivilegeNameA                 [ADVAPI32.@]
1230  *
1231  * See LookupPrivilegeNameW.
1232  */
1233 BOOL WINAPI
1234 LookupPrivilegeNameA( LPCSTR lpSystemName, PLUID lpLuid, LPSTR lpName,
1235  LPDWORD cchName)
1236 {
1237     UNICODE_STRING lpSystemNameW;
1238     BOOL ret;
1239     DWORD wLen = 0;
1240
1241     TRACE("%s %p %p %p\n", debugstr_a(lpSystemName), lpLuid, lpName, cchName);
1242
1243     RtlCreateUnicodeStringFromAsciiz(&lpSystemNameW, lpSystemName);
1244     ret = LookupPrivilegeNameW(lpSystemNameW.Buffer, lpLuid, NULL, &wLen);
1245     if (!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1246     {
1247         LPWSTR lpNameW = HeapAlloc(GetProcessHeap(), 0, wLen * sizeof(WCHAR));
1248
1249         ret = LookupPrivilegeNameW(lpSystemNameW.Buffer, lpLuid, lpNameW,
1250          &wLen);
1251         if (ret)
1252         {
1253             /* Windows crashes if cchName is NULL, so will I */
1254             int len = WideCharToMultiByte(CP_ACP, 0, lpNameW, -1, lpName,
1255              *cchName, NULL, NULL);
1256
1257             if (len == 0)
1258             {
1259                 /* WideCharToMultiByte failed */
1260                 ret = FALSE;
1261             }
1262             else if (len > *cchName)
1263             {
1264                 *cchName = len;
1265                 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1266                 ret = FALSE;
1267             }
1268             else
1269             {
1270                 /* WideCharToMultiByte succeeded, output length needs to be
1271                  * length not including NULL terminator
1272                  */
1273                 *cchName = len - 1;
1274             }
1275         }
1276         HeapFree(GetProcessHeap(), 0, lpNameW);
1277     }
1278     RtlFreeUnicodeString(&lpSystemNameW);
1279     return ret;
1280 }
1281
1282 /******************************************************************************
1283  * LookupPrivilegeNameW                 [ADVAPI32.@]
1284  *
1285  * Retrieves the privilege name referred to by the LUID lpLuid.
1286  *
1287  * PARAMS
1288  *  lpSystemName [I]   Name of the system
1289  *  lpLuid       [I]   Privilege value
1290  *  lpName       [O]   Name of the privilege
1291  *  cchName      [I/O] Number of characters in lpName.
1292  *
1293  * RETURNS
1294  *  Success: TRUE. lpName contains the name of the privilege whose value is
1295  *  *lpLuid.
1296  *  Failure: FALSE.
1297  *
1298  * REMARKS
1299  *  Only well-known privilege names (those defined in winnt.h) can be retrieved
1300  *  using this function.
1301  *  If the length of lpName is too small, on return *cchName will contain the
1302  *  number of WCHARs needed to contain the privilege, including the NULL
1303  *  terminator, and GetLastError will return ERROR_INSUFFICIENT_BUFFER.
1304  *  On success, *cchName will contain the number of characters stored in
1305  *  lpName, NOT including the NULL terminator.
1306  */
1307 BOOL WINAPI
1308 LookupPrivilegeNameW( LPCWSTR lpSystemName, PLUID lpLuid, LPWSTR lpName,
1309  LPDWORD cchName)
1310 {
1311     size_t privNameLen;
1312
1313     TRACE("%s,%p,%p,%p\n",debugstr_w(lpSystemName), lpLuid, lpName, cchName);
1314
1315     if (!ADVAPI_IsLocalComputer(lpSystemName))
1316     {
1317         SetLastError(RPC_S_SERVER_UNAVAILABLE);
1318         return FALSE;
1319     }
1320     if (lpLuid->HighPart || (lpLuid->LowPart < SE_MIN_WELL_KNOWN_PRIVILEGE ||
1321      lpLuid->LowPart > SE_MAX_WELL_KNOWN_PRIVILEGE))
1322     {
1323         SetLastError(ERROR_NO_SUCH_PRIVILEGE);
1324         return FALSE;
1325     }
1326     privNameLen = strlenW(WellKnownPrivNames[lpLuid->LowPart]);
1327     /* Windows crashes if cchName is NULL, so will I */
1328     if (*cchName <= privNameLen)
1329     {
1330         *cchName = privNameLen + 1;
1331         SetLastError(ERROR_INSUFFICIENT_BUFFER);
1332         return FALSE;
1333     }
1334     else
1335     {
1336         strcpyW(lpName, WellKnownPrivNames[lpLuid->LowPart]);
1337         *cchName = privNameLen;
1338         return TRUE;
1339     }
1340 }
1341
1342 /******************************************************************************
1343  * GetFileSecurityA [ADVAPI32.@]
1344  *
1345  * Obtains Specified information about the security of a file or directory.
1346  *
1347  * PARAMS
1348  *  lpFileName           [I] Name of the file to get info for
1349  *  RequestedInformation [I] SE_ flags from "winnt.h"
1350  *  pSecurityDescriptor  [O] Destination for security information
1351  *  nLength              [I] Length of pSecurityDescriptor
1352  *  lpnLengthNeeded      [O] Destination for length of returned security information
1353  *
1354  * RETURNS
1355  *  Success: TRUE. pSecurityDescriptor contains the requested information.
1356  *  Failure: FALSE. lpnLengthNeeded contains the required space to return the info.
1357  *
1358  * NOTES
1359  *  The information returned is constrained by the callers access rights and
1360  *  privileges.
1361  */
1362 BOOL WINAPI
1363 GetFileSecurityA( LPCSTR lpFileName,
1364                     SECURITY_INFORMATION RequestedInformation,
1365                     PSECURITY_DESCRIPTOR pSecurityDescriptor,
1366                     DWORD nLength, LPDWORD lpnLengthNeeded )
1367 {
1368     DWORD len;
1369     BOOL r;
1370     LPWSTR name = NULL;
1371
1372     if( lpFileName )
1373     {
1374         len = MultiByteToWideChar( CP_ACP, 0, lpFileName, -1, NULL, 0 );
1375         name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1376         MultiByteToWideChar( CP_ACP, 0, lpFileName, -1, name, len );
1377     }
1378
1379     r = GetFileSecurityW( name, RequestedInformation, pSecurityDescriptor,
1380                           nLength, lpnLengthNeeded );
1381     HeapFree( GetProcessHeap(), 0, name );
1382
1383     return r;
1384 }
1385
1386 /******************************************************************************
1387  * GetFileSecurityW [ADVAPI32.@]
1388  *
1389  * See GetFileSecurityA.
1390  */
1391 BOOL WINAPI
1392 GetFileSecurityW( LPCWSTR lpFileName,
1393                     SECURITY_INFORMATION RequestedInformation,
1394                     PSECURITY_DESCRIPTOR pSecurityDescriptor,
1395                     DWORD nLength, LPDWORD lpnLengthNeeded )
1396 {
1397     DWORD               nNeeded;
1398     LPBYTE      pBuffer;
1399     DWORD               iLocNow;
1400     SECURITY_DESCRIPTOR_RELATIVE *pSDRelative;
1401
1402     if(INVALID_FILE_ATTRIBUTES == GetFileAttributesW(lpFileName))
1403         return FALSE;
1404
1405     FIXME("(%s) : returns fake SECURITY_DESCRIPTOR\n", debugstr_w(lpFileName) );
1406
1407     nNeeded = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
1408     if (RequestedInformation & OWNER_SECURITY_INFORMATION)
1409         nNeeded += sizeof(sidWorld);
1410     if (RequestedInformation & GROUP_SECURITY_INFORMATION)
1411         nNeeded += sizeof(sidWorld);
1412     if (RequestedInformation & DACL_SECURITY_INFORMATION)
1413         nNeeded += WINE_SIZE_OF_WORLD_ACCESS_ACL;
1414     if (RequestedInformation & SACL_SECURITY_INFORMATION)
1415         nNeeded += WINE_SIZE_OF_WORLD_ACCESS_ACL;
1416
1417     *lpnLengthNeeded = nNeeded;
1418
1419     if (nNeeded > nLength)
1420             return TRUE;
1421
1422     if (!InitializeSecurityDescriptor(pSecurityDescriptor, SECURITY_DESCRIPTOR_REVISION))
1423         return FALSE;
1424
1425     pSDRelative = (PISECURITY_DESCRIPTOR_RELATIVE) pSecurityDescriptor;
1426     pSDRelative->Control |= SE_SELF_RELATIVE;
1427     pBuffer = (LPBYTE) pSDRelative;
1428     iLocNow = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
1429
1430     if (RequestedInformation & OWNER_SECURITY_INFORMATION)
1431     {
1432         memcpy(pBuffer + iLocNow, &sidWorld, sizeof(sidWorld));
1433         pSDRelative->Owner = iLocNow;
1434         iLocNow += sizeof(sidWorld);
1435     }
1436     if (RequestedInformation & GROUP_SECURITY_INFORMATION)
1437     {
1438         memcpy(pBuffer + iLocNow, &sidWorld, sizeof(sidWorld));
1439         pSDRelative->Group = iLocNow;
1440         iLocNow += sizeof(sidWorld);
1441     }
1442     if (RequestedInformation & DACL_SECURITY_INFORMATION)
1443     {
1444         GetWorldAccessACL((PACL) (pBuffer + iLocNow));
1445         pSDRelative->Dacl = iLocNow;
1446         iLocNow += WINE_SIZE_OF_WORLD_ACCESS_ACL;
1447     }
1448     if (RequestedInformation & SACL_SECURITY_INFORMATION)
1449     {
1450         GetWorldAccessACL((PACL) (pBuffer + iLocNow));
1451         pSDRelative->Sacl = iLocNow;
1452         /* iLocNow += WINE_SIZE_OF_WORLD_ACCESS_ACL; */
1453     }
1454     return TRUE;
1455 }
1456
1457
1458 /******************************************************************************
1459  * LookupAccountSidA [ADVAPI32.@]
1460  */
1461 BOOL WINAPI
1462 LookupAccountSidA(
1463         IN LPCSTR system,
1464         IN PSID sid,
1465         OUT LPSTR account,
1466         IN OUT LPDWORD accountSize,
1467         OUT LPSTR domain,
1468         IN OUT LPDWORD domainSize,
1469         OUT PSID_NAME_USE name_use )
1470 {
1471         static const char ac[] = "Administrator";
1472         static const char dm[] = "DOMAIN";
1473         FIXME("(%s,sid=%p,%p,%p(%lu),%p,%p(%lu),%p): semi-stub\n",
1474               debugstr_a(system),sid,
1475               account,accountSize,accountSize?*accountSize:0,
1476               domain,domainSize,domainSize?*domainSize:0,
1477               name_use);
1478
1479         if (accountSize) *accountSize = strlen(ac)+1;
1480         if (account && (*accountSize > strlen(ac)))
1481           strcpy(account, ac);
1482
1483         if (domainSize) *domainSize = strlen(dm)+1;
1484         if (domain && (*domainSize > strlen(dm)))
1485           strcpy(domain,dm);
1486
1487         if (name_use) *name_use = SidTypeUser;
1488         return TRUE;
1489 }
1490
1491 /******************************************************************************
1492  * LookupAccountSidW [ADVAPI32.@]
1493  *
1494  * PARAMS
1495  *   system      []
1496  *   sid         []
1497  *   account     []
1498  *   accountSize []
1499  *   domain      []
1500  *   domainSize  []
1501  *   name_use    []
1502  */
1503 BOOL WINAPI
1504 LookupAccountSidW(
1505         IN LPCWSTR system,
1506         IN PSID sid,
1507         OUT LPWSTR account,
1508         IN OUT LPDWORD accountSize,
1509         OUT LPWSTR domain,
1510         IN OUT LPDWORD domainSize,
1511         OUT PSID_NAME_USE name_use )
1512 {
1513     static const WCHAR ac[] = {'A','d','m','i','n','i','s','t','r','a','t','o','r',0};
1514     static const WCHAR dm[] = {'D','O','M','A','I','N',0};
1515         FIXME("(%s,sid=%p,%p,%p(%lu),%p,%p(%lu),%p): semi-stub\n",
1516               debugstr_w(system),sid,
1517               account,accountSize,accountSize?*accountSize:0,
1518               domain,domainSize,domainSize?*domainSize:0,
1519               name_use);
1520
1521         if (accountSize) *accountSize = strlenW(ac)+1;
1522         if (account && (*accountSize > strlenW(ac)))
1523             strcpyW(account, ac);
1524
1525         if (domainSize) *domainSize = strlenW(dm)+1;
1526         if (domain && (*domainSize > strlenW(dm)))
1527             strcpyW(domain,dm);
1528
1529         if (name_use) *name_use = SidTypeUser;
1530         return TRUE;
1531 }
1532
1533 /******************************************************************************
1534  * SetFileSecurityA [ADVAPI32.@]
1535  *
1536  * See SetFileSecurityW.
1537  */
1538 BOOL WINAPI SetFileSecurityA( LPCSTR lpFileName,
1539                                 SECURITY_INFORMATION RequestedInformation,
1540                                 PSECURITY_DESCRIPTOR pSecurityDescriptor)
1541 {
1542     DWORD len;
1543     BOOL r;
1544     LPWSTR name = NULL;
1545
1546     if( lpFileName )
1547     {
1548         len = MultiByteToWideChar( CP_ACP, 0, lpFileName, -1, NULL, 0 );
1549         name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1550         MultiByteToWideChar( CP_ACP, 0, lpFileName, -1, name, len );
1551     }
1552
1553     r = SetFileSecurityW( name, RequestedInformation, pSecurityDescriptor );
1554     HeapFree( GetProcessHeap(), 0, name );
1555
1556     return r;
1557 }
1558
1559 /******************************************************************************
1560  * SetFileSecurityW [ADVAPI32.@]
1561  *
1562  * Sets the security of a file or directory.
1563  *
1564  * PARAMS
1565  *   lpFileName           []
1566  *   RequestedInformation []
1567  *   pSecurityDescriptor  []
1568  *
1569  * RETURNS
1570  *  Success: TRUE.
1571  *  Failure: FALSE.
1572  */
1573 BOOL WINAPI
1574 SetFileSecurityW( LPCWSTR lpFileName,
1575                     SECURITY_INFORMATION RequestedInformation,
1576                     PSECURITY_DESCRIPTOR pSecurityDescriptor )
1577 {
1578   FIXME("(%s) : stub\n", debugstr_w(lpFileName) );
1579   return TRUE;
1580 }
1581
1582 /******************************************************************************
1583  * QueryWindows31FilesMigration [ADVAPI32.@]
1584  *
1585  * PARAMS
1586  *   x1 []
1587  */
1588 BOOL WINAPI
1589 QueryWindows31FilesMigration( DWORD x1 )
1590 {
1591         FIXME("(%ld):stub\n",x1);
1592         return TRUE;
1593 }
1594
1595 /******************************************************************************
1596  * SynchronizeWindows31FilesAndWindowsNTRegistry [ADVAPI32.@]
1597  *
1598  * PARAMS
1599  *   x1 []
1600  *   x2 []
1601  *   x3 []
1602  *   x4 []
1603  */
1604 BOOL WINAPI
1605 SynchronizeWindows31FilesAndWindowsNTRegistry( DWORD x1, DWORD x2, DWORD x3,
1606                                                DWORD x4 )
1607 {
1608         FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx):stub\n",x1,x2,x3,x4);
1609         return TRUE;
1610 }
1611
1612 /******************************************************************************
1613  * NotifyBootConfigStatus [ADVAPI32.@]
1614  *
1615  * PARAMS
1616  *   x1 []
1617  */
1618 BOOL WINAPI
1619 NotifyBootConfigStatus( DWORD x1 )
1620 {
1621         FIXME("(0x%08lx):stub\n",x1);
1622         return 1;
1623 }
1624
1625 /******************************************************************************
1626  * RevertToSelf [ADVAPI32.@]
1627  *
1628  * Ends the impersonation of a user.
1629  *
1630  * PARAMS
1631  *   void []
1632  *
1633  * RETURNS
1634  *  Success: TRUE.
1635  *  Failure: FALSE.
1636  */
1637 BOOL WINAPI
1638 RevertToSelf( void )
1639 {
1640     HANDLE Token = NULL;
1641     return set_ntstatus( NtSetInformationThread( GetCurrentThread(),
1642         ThreadImpersonationToken, &Token, sizeof(Token) ) );
1643 }
1644
1645 /******************************************************************************
1646  * ImpersonateSelf [ADVAPI32.@]
1647  *
1648  * Makes an impersonation token that represents the process user and assigns
1649  * to the current thread.
1650  *
1651  * PARAMS
1652  *  ImpersonationLevel [I] Level at which to impersonate.
1653  *
1654  * RETURNS
1655  *  Success: TRUE.
1656  *  Failure: FALSE.
1657  */
1658 BOOL WINAPI
1659 ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
1660 {
1661     return set_ntstatus( RtlImpersonateSelf( ImpersonationLevel ) );
1662 }
1663
1664 /******************************************************************************
1665  * ImpersonateLoggedOnUser [ADVAPI32.@]
1666  */
1667 BOOL WINAPI ImpersonateLoggedOnUser(HANDLE hToken)
1668 {
1669     FIXME("(%p):stub returning FALSE\n", hToken);
1670     return FALSE;
1671 }
1672
1673 /******************************************************************************
1674  * AccessCheck [ADVAPI32.@]
1675  */
1676 BOOL WINAPI
1677 AccessCheck(
1678         PSECURITY_DESCRIPTOR SecurityDescriptor,
1679         HANDLE ClientToken,
1680         DWORD DesiredAccess,
1681         PGENERIC_MAPPING GenericMapping,
1682         PPRIVILEGE_SET PrivilegeSet,
1683         LPDWORD PrivilegeSetLength,
1684         LPDWORD GrantedAccess,
1685         LPBOOL AccessStatus)
1686 {
1687     NTSTATUS access_status;
1688     BOOL ret = set_ntstatus( NtAccessCheck(SecurityDescriptor, ClientToken, DesiredAccess,
1689                                            GenericMapping, PrivilegeSet, PrivilegeSetLength,
1690                                            GrantedAccess, &access_status) );
1691     if (ret) *AccessStatus = set_ntstatus( access_status );
1692     return ret;
1693 }
1694
1695
1696 /******************************************************************************
1697  * AccessCheckByType [ADVAPI32.@]
1698  */
1699 BOOL WINAPI AccessCheckByType(
1700     PSECURITY_DESCRIPTOR pSecurityDescriptor,
1701     PSID PrincipalSelfSid,
1702     HANDLE ClientToken,
1703     DWORD DesiredAccess,
1704     POBJECT_TYPE_LIST ObjectTypeList,
1705     DWORD ObjectTypeListLength,
1706     PGENERIC_MAPPING GenericMapping,
1707     PPRIVILEGE_SET PrivilegeSet,
1708     LPDWORD PrivilegeSetLength,
1709     LPDWORD GrantedAccess,
1710     LPBOOL AccessStatus)
1711 {
1712         FIXME("stub\n");
1713
1714         *AccessStatus = TRUE;
1715
1716         return !*AccessStatus;
1717 }
1718
1719 /******************************************************************************
1720  * MapGenericMask [ADVAPI32.@]
1721  *
1722  * Maps generic access rights into specific access rights according to the
1723  * supplied mapping.
1724  *
1725  * PARAMS
1726  *  AccessMask     [I/O] Access rights.
1727  *  GenericMapping [I] The mapping between generic and specific rights.
1728  *
1729  * RETURNS
1730  *  Nothing.
1731  */
1732 VOID WINAPI MapGenericMask( PDWORD AccessMask, PGENERIC_MAPPING GenericMapping )
1733 {
1734     RtlMapGenericMask( AccessMask, GenericMapping );
1735 }
1736
1737 /*************************************************************************
1738  * SetKernelObjectSecurity [ADVAPI32.@]
1739  */
1740 BOOL WINAPI SetKernelObjectSecurity (
1741         IN HANDLE Handle,
1742         IN SECURITY_INFORMATION SecurityInformation,
1743         IN PSECURITY_DESCRIPTOR SecurityDescriptor )
1744 {
1745     return set_ntstatus (NtSetSecurityObject (Handle, SecurityInformation, SecurityDescriptor));
1746 }
1747
1748
1749 /******************************************************************************
1750  *  AddAuditAccessAce [ADVAPI32.@]
1751  */
1752 BOOL WINAPI AddAuditAccessAce(
1753     IN OUT PACL pAcl,
1754     IN DWORD dwAceRevision,
1755     IN DWORD dwAccessMask,
1756     IN PSID pSid,
1757     IN BOOL bAuditSuccess,
1758     IN BOOL bAuditFailure)
1759 {
1760     return set_ntstatus( RtlAddAuditAccessAce(pAcl, dwAceRevision, dwAccessMask, pSid,
1761                                               bAuditSuccess, bAuditFailure) );
1762 }
1763
1764 /******************************************************************************
1765  * LookupAccountNameA [ADVAPI32.@]
1766  */
1767 BOOL WINAPI
1768 LookupAccountNameA(
1769         IN LPCSTR system,
1770         IN LPCSTR account,
1771         OUT PSID sid,
1772         OUT LPDWORD cbSid,
1773         LPSTR ReferencedDomainName,
1774         IN OUT LPDWORD cbReferencedDomainName,
1775         OUT PSID_NAME_USE name_use )
1776 {
1777     /* Default implementation: Always return a default SID */
1778     SID_IDENTIFIER_AUTHORITY identifierAuthority = {SECURITY_NT_AUTHORITY};
1779     BOOL ret;
1780     PSID pSid;
1781     static const char dm[] = "DOMAIN";
1782
1783     FIXME("(%s,%s,%p,%p,%p,%p,%p), stub.\n",system,account,sid,cbSid,ReferencedDomainName,cbReferencedDomainName,name_use);
1784
1785     ret = AllocateAndInitializeSid(&identifierAuthority,
1786         2,
1787         SECURITY_BUILTIN_DOMAIN_RID,
1788         DOMAIN_ALIAS_RID_ADMINS,
1789         0, 0, 0, 0, 0, 0,
1790         &pSid);
1791
1792     if (!ret)
1793        return FALSE;
1794     if(!RtlValidSid(pSid))
1795     {
1796        FreeSid(pSid);
1797        return FALSE;
1798     }
1799
1800     if (sid != NULL && (*cbSid >= GetLengthSid(pSid)))
1801        CopySid(*cbSid, sid, pSid);
1802     if (*cbSid < GetLengthSid(pSid))
1803     {
1804        SetLastError(ERROR_INSUFFICIENT_BUFFER);
1805        ret = FALSE;
1806     }
1807     *cbSid = GetLengthSid(pSid);
1808
1809     if (ReferencedDomainName != NULL && (*cbReferencedDomainName > strlen(dm)))
1810       strcpy(ReferencedDomainName, dm);
1811     if (*cbReferencedDomainName <= strlen(dm))
1812     {
1813        SetLastError(ERROR_INSUFFICIENT_BUFFER);
1814        ret = FALSE;
1815     }
1816     *cbReferencedDomainName = strlen(dm)+1;
1817
1818     FreeSid(pSid);
1819
1820     return ret;
1821 }
1822
1823 /******************************************************************************
1824  * LookupAccountNameW [ADVAPI32.@]
1825  */
1826 BOOL WINAPI LookupAccountNameW( LPCWSTR lpSystemName, LPCWSTR lpAccountName, PSID Sid,
1827                                 LPDWORD cbSid, LPWSTR ReferencedDomainName,
1828                                 LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse )
1829 {
1830     FIXME("%s %s %p %p %p %p %p - stub\n", debugstr_w(lpSystemName), debugstr_w(lpAccountName),
1831           Sid, cbSid, ReferencedDomainName, cchReferencedDomainName, peUse);
1832
1833     return FALSE;
1834 }
1835
1836 /******************************************************************************
1837  * PrivilegeCheck [ADVAPI32.@]
1838  */
1839 BOOL WINAPI PrivilegeCheck( HANDLE ClientToken, PPRIVILEGE_SET RequiredPrivileges, LPBOOL pfResult)
1840 {
1841     BOOL ret;
1842     BOOLEAN Result;
1843
1844     TRACE("%p %p %p\n", ClientToken, RequiredPrivileges, pfResult);
1845
1846     ret = set_ntstatus (NtPrivilegeCheck (ClientToken, RequiredPrivileges, &Result));
1847     if (ret)
1848         *pfResult = Result;
1849     return ret;
1850 }
1851
1852 /******************************************************************************
1853  * AccessCheckAndAuditAlarmA [ADVAPI32.@]
1854  */
1855 BOOL WINAPI AccessCheckAndAuditAlarmA(LPCSTR Subsystem, LPVOID HandleId, LPSTR ObjectTypeName,
1856   LPSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess,
1857   PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess,
1858   LPBOOL AccessStatus, LPBOOL pfGenerateOnClose)
1859 {
1860         FIXME("stub (%s,%p,%s,%s,%p,%08lx,%p,%x,%p,%p,%p)\n", debugstr_a(Subsystem),
1861                 HandleId, debugstr_a(ObjectTypeName), debugstr_a(ObjectName),
1862                 SecurityDescriptor, DesiredAccess, GenericMapping,
1863                 ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose);
1864         return TRUE;
1865 }
1866
1867 /******************************************************************************
1868  * AccessCheckAndAuditAlarmW [ADVAPI32.@]
1869  */
1870 BOOL WINAPI AccessCheckAndAuditAlarmW(LPCWSTR Subsystem, LPVOID HandleId, LPWSTR ObjectTypeName,
1871   LPWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess,
1872   PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess,
1873   LPBOOL AccessStatus, LPBOOL pfGenerateOnClose)
1874 {
1875         FIXME("stub (%s,%p,%s,%s,%p,%08lx,%p,%x,%p,%p,%p)\n", debugstr_w(Subsystem),
1876                 HandleId, debugstr_w(ObjectTypeName), debugstr_w(ObjectName),
1877                 SecurityDescriptor, DesiredAccess, GenericMapping,
1878                 ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose);
1879         return TRUE;
1880 }
1881
1882 BOOL WINAPI ObjectCloseAuditAlarmA(LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose)
1883 {
1884     FIXME("stub (%s,%p,%x)\n", debugstr_a(SubsystemName), HandleId, GenerateOnClose);
1885
1886     return TRUE;
1887 }
1888
1889 BOOL WINAPI ObjectCloseAuditAlarmW(LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose)
1890 {
1891     FIXME("stub (%s,%p,%x)\n", debugstr_w(SubsystemName), HandleId, GenerateOnClose);
1892
1893     return TRUE;
1894 }
1895
1896 BOOL WINAPI ObjectOpenAuditAlarmA(LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName,
1897   LPSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess,
1898   DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted,
1899   LPBOOL GenerateOnClose)
1900 {
1901         FIXME("stub (%s,%p,%s,%s,%p,%p,0x%08lx,0x%08lx,%p,%x,%x,%p)\n", debugstr_a(SubsystemName),
1902                 HandleId, debugstr_a(ObjectTypeName), debugstr_a(ObjectName), pSecurityDescriptor,
1903         ClientToken, DesiredAccess, GrantedAccess, Privileges, ObjectCreation, AccessGranted,
1904         GenerateOnClose);
1905
1906     return TRUE;
1907 }
1908
1909 BOOL WINAPI ObjectOpenAuditAlarmW(LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName,
1910   LPWSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess,
1911   DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted,
1912   LPBOOL GenerateOnClose)
1913 {
1914     FIXME("stub (%s,%p,%s,%s,%p,%p,0x%08lx,0x%08lx,%p,%x,%x,%p)\n", debugstr_w(SubsystemName),
1915         HandleId, debugstr_w(ObjectTypeName), debugstr_w(ObjectName), pSecurityDescriptor,
1916         ClientToken, DesiredAccess, GrantedAccess, Privileges, ObjectCreation, AccessGranted,
1917         GenerateOnClose);
1918
1919     return TRUE;
1920 }
1921
1922 BOOL WINAPI ObjectPrivilegeAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken,
1923   DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted)
1924 {
1925     FIXME("stub (%s,%p,%p,0x%08lx,%p,%x)\n", debugstr_a(SubsystemName), HandleId, ClientToken,
1926           DesiredAccess, Privileges, AccessGranted);
1927
1928     return TRUE;
1929 }
1930
1931 BOOL WINAPI ObjectPrivilegeAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken,
1932   DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted)
1933 {
1934     FIXME("stub (%s,%p,%p,0x%08lx,%p,%x)\n", debugstr_w(SubsystemName), HandleId, ClientToken,
1935           DesiredAccess, Privileges, AccessGranted);
1936
1937     return TRUE;
1938 }
1939
1940 BOOL WINAPI PrivilegedServiceAuditAlarmA( LPCSTR SubsystemName, LPCSTR ServiceName, HANDLE ClientToken,
1941                                    PPRIVILEGE_SET Privileges, BOOL AccessGranted)
1942 {
1943     FIXME("stub (%s,%s,%p,%p,%x)\n", debugstr_a(SubsystemName), debugstr_a(ServiceName),
1944           ClientToken, Privileges, AccessGranted);
1945
1946     return TRUE;
1947 }
1948
1949 BOOL WINAPI PrivilegedServiceAuditAlarmW( LPCWSTR SubsystemName, LPCWSTR ServiceName, HANDLE ClientToken,
1950                                    PPRIVILEGE_SET Privileges, BOOL AccessGranted)
1951 {
1952     FIXME("stub %s,%s,%p,%p,%x)\n", debugstr_w(SubsystemName), debugstr_w(ServiceName),
1953           ClientToken, Privileges, AccessGranted);
1954
1955     return TRUE;
1956 }
1957
1958 /******************************************************************************
1959  * GetSecurityInfo [ADVAPI32.@]
1960  */
1961 DWORD WINAPI GetSecurityInfo(
1962     HANDLE hObject, SE_OBJECT_TYPE ObjectType,
1963     SECURITY_INFORMATION SecurityInfo, PSID *ppsidOwner,
1964     PSID *ppsidGroup, PACL *ppDacl, PACL *ppSacl,
1965     PSECURITY_DESCRIPTOR *ppSecurityDescriptor
1966 )
1967 {
1968   FIXME("stub!\n");
1969   return ERROR_BAD_PROVIDER;
1970 }
1971
1972 /******************************************************************************
1973  * GetSecurityInfoExW [ADVAPI32.@]
1974  */
1975 DWORD WINAPI GetSecurityInfoExW(
1976         HANDLE hObject, SE_OBJECT_TYPE ObjectType,
1977         SECURITY_INFORMATION SecurityInfo, LPCWSTR lpProvider,
1978         LPCWSTR lpProperty, PACTRL_ACCESSW *ppAccessList,
1979         PACTRL_AUDITW *ppAuditList, LPWSTR *lppOwner, LPWSTR *lppGroup
1980 )
1981 {
1982   FIXME("stub!\n");
1983   return ERROR_BAD_PROVIDER;
1984 }
1985
1986 /******************************************************************************
1987  * BuildExplicitAccessWithNameA [ADVAPI32.@]
1988  */
1989 VOID WINAPI BuildExplicitAccessWithNameA( PEXPLICIT_ACCESSA pExplicitAccess,
1990                                           LPSTR pTrusteeName, DWORD AccessPermissions,
1991                                           ACCESS_MODE AccessMode, DWORD Inheritance )
1992 {
1993     TRACE("%p %s 0x%08lx 0x%08x 0x%08lx\n", pExplicitAccess, debugstr_a(pTrusteeName),
1994           AccessPermissions, AccessMode, Inheritance);
1995
1996     pExplicitAccess->grfAccessPermissions = AccessPermissions;
1997     pExplicitAccess->grfAccessMode = AccessMode;
1998     pExplicitAccess->grfInheritance = Inheritance;
1999
2000     pExplicitAccess->Trustee.pMultipleTrustee = NULL;
2001     pExplicitAccess->Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2002     pExplicitAccess->Trustee.TrusteeForm = TRUSTEE_IS_NAME;
2003     pExplicitAccess->Trustee.TrusteeType = TRUSTEE_IS_UNKNOWN;
2004     pExplicitAccess->Trustee.ptstrName = pTrusteeName;
2005 }
2006
2007 /******************************************************************************
2008  * BuildExplicitAccessWithNameW [ADVAPI32.@]
2009  */
2010 VOID WINAPI BuildExplicitAccessWithNameW( PEXPLICIT_ACCESSW pExplicitAccess,
2011                                           LPWSTR pTrusteeName, DWORD AccessPermissions,
2012                                           ACCESS_MODE AccessMode, DWORD Inheritance )
2013 {
2014     TRACE("%p %s 0x%08lx 0x%08x 0x%08lx\n", pExplicitAccess, debugstr_w(pTrusteeName),
2015           AccessPermissions, AccessMode, Inheritance);
2016
2017     pExplicitAccess->grfAccessPermissions = AccessPermissions;
2018     pExplicitAccess->grfAccessMode = AccessMode;
2019     pExplicitAccess->grfInheritance = Inheritance;
2020
2021     pExplicitAccess->Trustee.pMultipleTrustee = NULL;
2022     pExplicitAccess->Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2023     pExplicitAccess->Trustee.TrusteeForm = TRUSTEE_IS_NAME;
2024     pExplicitAccess->Trustee.TrusteeType = TRUSTEE_IS_UNKNOWN;
2025     pExplicitAccess->Trustee.ptstrName = pTrusteeName;
2026 }
2027
2028 /******************************************************************************
2029  * BuildTrusteeWithObjectsAndNameA [ADVAPI32.@]
2030  */
2031 VOID WINAPI BuildTrusteeWithObjectsAndNameA( PTRUSTEEA pTrustee, POBJECTS_AND_NAME_A pObjName,
2032                                              SE_OBJECT_TYPE ObjectType, LPSTR ObjectTypeName,
2033                                              LPSTR InheritedObjectTypeName, LPSTR Name )
2034 {
2035     TRACE("%p %p 0x%08x %p %p %s\n", pTrustee, pObjName,
2036           ObjectType, ObjectTypeName, InheritedObjectTypeName, debugstr_a(Name));
2037
2038     pTrustee->pMultipleTrustee = NULL;
2039     pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2040     pTrustee->TrusteeForm = TRUSTEE_IS_OBJECTS_AND_NAME;
2041     pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2042     pTrustee->ptstrName = Name;
2043 }
2044
2045 /******************************************************************************
2046  * BuildTrusteeWithObjectsAndNameW [ADVAPI32.@]
2047  */
2048 VOID WINAPI BuildTrusteeWithObjectsAndNameW( PTRUSTEEW pTrustee, POBJECTS_AND_NAME_W pObjName,
2049                                              SE_OBJECT_TYPE ObjectType, LPWSTR ObjectTypeName,
2050                                              LPWSTR InheritedObjectTypeName, LPWSTR Name )
2051 {
2052     TRACE("%p %p 0x%08x %p %p %s\n", pTrustee, pObjName,
2053           ObjectType, ObjectTypeName, InheritedObjectTypeName, debugstr_w(Name));
2054
2055     pTrustee->pMultipleTrustee = NULL;
2056     pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2057     pTrustee->TrusteeForm = TRUSTEE_IS_OBJECTS_AND_NAME;
2058     pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2059     pTrustee->ptstrName = Name;
2060 }
2061
2062 VOID WINAPI BuildTrusteeWithObjectsAndSidA( PTRUSTEEA pTrustee, POBJECTS_AND_SID pObjSid,
2063                                             GUID* pObjectGuid, GUID* pInheritedObjectGuid, PSID pSid )
2064 {
2065     TRACE("%p %p %p %p %p\n", pTrustee, pObjSid, pObjectGuid, pInheritedObjectGuid, pSid);
2066
2067     pTrustee->pMultipleTrustee = NULL;
2068     pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2069     pTrustee->TrusteeForm = TRUSTEE_IS_OBJECTS_AND_SID;
2070     pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2071     pTrustee->ptstrName = (LPSTR) pSid;
2072 }
2073
2074 VOID WINAPI BuildTrusteeWithObjectsAndSidW( PTRUSTEEW pTrustee, POBJECTS_AND_SID pObjSid,
2075                                             GUID* pObjectGuid, GUID* pInheritedObjectGuid, PSID pSid )
2076 {
2077     TRACE("%p %p %p %p %p\n", pTrustee, pObjSid, pObjectGuid, pInheritedObjectGuid, pSid);
2078
2079     pTrustee->pMultipleTrustee = NULL;
2080     pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2081     pTrustee->TrusteeForm = TRUSTEE_IS_OBJECTS_AND_SID;
2082     pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2083     pTrustee->ptstrName = (LPWSTR) pSid;
2084 }
2085
2086 /******************************************************************************
2087  * BuildTrusteeWithSidA [ADVAPI32.@]
2088  */
2089 VOID WINAPI BuildTrusteeWithSidA(PTRUSTEEA pTrustee, PSID pSid)
2090 {
2091     TRACE("%p %p\n", pTrustee, pSid);
2092
2093     pTrustee->pMultipleTrustee = NULL;
2094     pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2095     pTrustee->TrusteeForm = TRUSTEE_IS_SID;
2096     pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2097     pTrustee->ptstrName = (LPSTR) pSid;
2098 }
2099
2100 /******************************************************************************
2101  * BuildTrusteeWithSidW [ADVAPI32.@]
2102  */
2103 VOID WINAPI BuildTrusteeWithSidW(PTRUSTEEW pTrustee, PSID pSid)
2104 {
2105     TRACE("%p %p\n", pTrustee, pSid);
2106
2107     pTrustee->pMultipleTrustee = NULL;
2108     pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2109     pTrustee->TrusteeForm = TRUSTEE_IS_SID;
2110     pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2111     pTrustee->ptstrName = (LPWSTR) pSid;
2112 }
2113
2114 /******************************************************************************
2115  * BuildTrusteeWithNameA [ADVAPI32.@]
2116  */
2117 VOID WINAPI BuildTrusteeWithNameA(PTRUSTEEA pTrustee, LPSTR name)
2118 {
2119     TRACE("%p %s\n", pTrustee, debugstr_a(name) );
2120
2121     pTrustee->pMultipleTrustee = NULL;
2122     pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2123     pTrustee->TrusteeForm = TRUSTEE_IS_NAME;
2124     pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2125     pTrustee->ptstrName = name;
2126 }
2127
2128 /******************************************************************************
2129  * BuildTrusteeWithNameW [ADVAPI32.@]
2130  */
2131 VOID WINAPI BuildTrusteeWithNameW(PTRUSTEEW pTrustee, LPWSTR name)
2132 {
2133     TRACE("%p %s\n", pTrustee, debugstr_w(name) );
2134
2135     pTrustee->pMultipleTrustee = NULL;
2136     pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2137     pTrustee->TrusteeForm = TRUSTEE_IS_NAME;
2138     pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2139     pTrustee->ptstrName = name;
2140 }
2141
2142 /******************************************************************************
2143  * GetTrusteeFormA [ADVAPI32.@]
2144  */
2145 TRUSTEE_FORM WINAPI GetTrusteeFormA(PTRUSTEEA pTrustee)
2146 {
2147     TRACE("(%p)\n", pTrustee);
2148
2149     if (!pTrustee)
2150         return TRUSTEE_BAD_FORM;
2151
2152     return pTrustee->TrusteeForm;
2153 }
2154
2155 /******************************************************************************
2156  * GetTrusteeFormW [ADVAPI32.@]
2157  */
2158 TRUSTEE_FORM WINAPI GetTrusteeFormW(PTRUSTEEW pTrustee)
2159 {
2160     TRACE("(%p)\n", pTrustee);
2161
2162     if (!pTrustee)
2163         return TRUSTEE_BAD_FORM;
2164
2165     return pTrustee->TrusteeForm;
2166 }
2167
2168 /******************************************************************************
2169  * GetTrusteeNameA [ADVAPI32.@]
2170  */
2171 LPSTR WINAPI GetTrusteeNameA(PTRUSTEEA pTrustee)
2172 {
2173     TRACE("(%p)\n", pTrustee);
2174
2175     if (!pTrustee)
2176         return NULL;
2177
2178     return pTrustee->ptstrName;
2179 }
2180
2181 /******************************************************************************
2182  * GetTrusteeNameW [ADVAPI32.@]
2183  */
2184 LPWSTR WINAPI GetTrusteeNameW(PTRUSTEEW pTrustee)
2185 {
2186     TRACE("(%p)\n", pTrustee);
2187
2188     if (!pTrustee)
2189         return NULL;
2190
2191     return pTrustee->ptstrName;
2192 }
2193
2194 /******************************************************************************
2195  * GetTrusteeTypeA [ADVAPI32.@]
2196  */
2197 TRUSTEE_TYPE WINAPI GetTrusteeTypeA(PTRUSTEEA pTrustee)
2198 {
2199     TRACE("(%p)\n", pTrustee);
2200
2201     if (!pTrustee)
2202         return TRUSTEE_IS_UNKNOWN;
2203
2204     return pTrustee->TrusteeType;
2205 }
2206
2207 /******************************************************************************
2208  * GetTrusteeTypeW [ADVAPI32.@]
2209  */
2210 TRUSTEE_TYPE WINAPI GetTrusteeTypeW(PTRUSTEEW pTrustee)
2211 {
2212     TRACE("(%p)\n", pTrustee);
2213
2214     if (!pTrustee)
2215         return TRUSTEE_IS_UNKNOWN;
2216
2217     return pTrustee->TrusteeType;
2218 }
2219
2220 BOOL WINAPI SetAclInformation( PACL pAcl, LPVOID pAclInformation,
2221                                DWORD nAclInformationLength,
2222                                ACL_INFORMATION_CLASS dwAclInformationClass )
2223 {
2224     FIXME("%p %p 0x%08lx 0x%08x - stub\n", pAcl, pAclInformation,
2225           nAclInformationLength, dwAclInformationClass);
2226
2227     return TRUE;
2228 }
2229
2230 /******************************************************************************
2231  * SetEntriesInAclA [ADVAPI32.@]
2232  */
2233 DWORD WINAPI SetEntriesInAclA( ULONG count, PEXPLICIT_ACCESSA pEntries,
2234                                PACL OldAcl, PACL* NewAcl )
2235 {
2236     FIXME("%ld %p %p %p\n",count,pEntries,OldAcl,NewAcl);
2237     return ERROR_CALL_NOT_IMPLEMENTED;
2238 }
2239
2240 /******************************************************************************
2241  * SetEntriesInAclW [ADVAPI32.@]
2242  */
2243 DWORD WINAPI SetEntriesInAclW( ULONG count, PEXPLICIT_ACCESSW pEntries,
2244                                PACL OldAcl, PACL* NewAcl )
2245 {
2246     FIXME("%ld %p %p %p\n",count,pEntries,OldAcl,NewAcl);
2247     return ERROR_CALL_NOT_IMPLEMENTED;
2248 }
2249
2250 /******************************************************************************
2251  * SetNamedSecurityInfoA [ADVAPI32.@]
2252  */
2253 DWORD WINAPI SetNamedSecurityInfoA(LPSTR pObjectName,
2254         SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo,
2255         PSID psidOwner, PSID psidGroup, PACL pDacl, PACL pSacl)
2256 {
2257     DWORD len;
2258     LPWSTR wstr = NULL;
2259     DWORD r;
2260
2261     TRACE("%s %d %ld %p %p %p %p\n", debugstr_a(pObjectName), ObjectType,
2262            SecurityInfo, psidOwner, psidGroup, pDacl, pSacl);
2263
2264     if( pObjectName )
2265     {
2266         len = MultiByteToWideChar( CP_ACP, 0, pObjectName, -1, NULL, 0 );
2267         wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR));
2268         MultiByteToWideChar( CP_ACP, 0, pObjectName, -1, wstr, len );
2269     }
2270
2271     r = SetNamedSecurityInfoW( wstr, ObjectType, SecurityInfo, psidOwner,
2272                            psidGroup, pDacl, pSacl );
2273
2274     HeapFree( GetProcessHeap(), 0, wstr );
2275
2276     return r;
2277 }
2278
2279 BOOL WINAPI SetPrivateObjectSecurity( SECURITY_INFORMATION SecurityInformation,
2280     PSECURITY_DESCRIPTOR ModificationDescriptor,
2281     PSECURITY_DESCRIPTOR* ObjectsSecurityDescriptor,
2282     PGENERIC_MAPPING GenericMapping,
2283     HANDLE Token )
2284 {
2285     FIXME("0x%08lx %p %p %p %p - stub\n", SecurityInformation, ModificationDescriptor,
2286           ObjectsSecurityDescriptor, GenericMapping, Token);
2287
2288     return TRUE;
2289 }
2290
2291 BOOL WINAPI SetSecurityDescriptorControl( PSECURITY_DESCRIPTOR pSecurityDescriptor,
2292   SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest,
2293   SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet )
2294 {
2295     FIXME("%p 0x%08x 0x%08x - stub\n", pSecurityDescriptor, ControlBitsOfInterest,
2296           ControlBitsToSet);
2297
2298     return TRUE;
2299 }
2300
2301 BOOL WINAPI AreAllAccessesGranted( DWORD GrantedAccess, DWORD DesiredAccess )
2302 {
2303     return RtlAreAllAccessesGranted( GrantedAccess, DesiredAccess );
2304 }
2305
2306 /******************************************************************************
2307  * AreAnyAccessesGranted [ADVAPI32.@]
2308  *
2309  * Determines whether or not any of a set of specified access permissions have
2310  * been granted or not.
2311  *
2312  * PARAMS
2313  *   GrantedAccess [I] The permissions that have been granted.
2314  *   DesiredAccess [I] The permissions that you want to have.
2315  *
2316  * RETURNS
2317  *   Nonzero if any of the permissions have been granted, zero if none of the
2318  *   permissions have been granted.
2319  */
2320
2321 BOOL WINAPI AreAnyAccessesGranted( DWORD GrantedAccess, DWORD DesiredAccess )
2322 {
2323     return RtlAreAnyAccessesGranted( GrantedAccess, DesiredAccess );
2324 }
2325
2326 /******************************************************************************
2327  * SetNamedSecurityInfoW [ADVAPI32.@]
2328  */
2329 DWORD WINAPI SetNamedSecurityInfoW(LPWSTR pObjectName,
2330         SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo,
2331         PSID psidOwner, PSID psidGroup, PACL pDacl, PACL pSacl)
2332 {
2333     FIXME("%s %d %ld %p %p %p %p\n", debugstr_w(pObjectName), ObjectType,
2334            SecurityInfo, psidOwner, psidGroup, pDacl, pSacl);
2335     return ERROR_SUCCESS;
2336 }
2337
2338 /******************************************************************************
2339  * GetExplicitEntriesFromAclA [ADVAPI32.@]
2340  */
2341 DWORD WINAPI GetExplicitEntriesFromAclA( PACL pacl, PULONG pcCountOfExplicitEntries,
2342         PEXPLICIT_ACCESSA* pListOfExplicitEntries)
2343 {
2344     FIXME("%p %p %p\n",pacl, pcCountOfExplicitEntries, pListOfExplicitEntries);
2345     return ERROR_CALL_NOT_IMPLEMENTED;
2346 }
2347
2348 /******************************************************************************
2349  * GetExplicitEntriesFromAclW [ADVAPI32.@]
2350  */
2351 DWORD WINAPI GetExplicitEntriesFromAclW( PACL pacl, PULONG pcCountOfExplicitEntries,
2352         PEXPLICIT_ACCESSW* pListOfExplicitEntries)
2353 {
2354     FIXME("%p %p %p\n",pacl, pcCountOfExplicitEntries, pListOfExplicitEntries);
2355     return ERROR_CALL_NOT_IMPLEMENTED;
2356 }
2357
2358
2359 /******************************************************************************
2360  * ParseAclStringFlags
2361  */
2362 static DWORD ParseAclStringFlags(LPCWSTR* StringAcl)
2363 {
2364     DWORD flags = 0;
2365     LPCWSTR szAcl = *StringAcl;
2366
2367     while (*szAcl != '(')
2368     {
2369         if (*szAcl == 'P')
2370         {
2371             flags |= SE_DACL_PROTECTED;
2372         }
2373         else if (*szAcl == 'A')
2374         {
2375             szAcl++;
2376             if (*szAcl == 'R')
2377                 flags |= SE_DACL_AUTO_INHERIT_REQ;
2378             else if (*szAcl == 'I')
2379                 flags |= SE_DACL_AUTO_INHERITED;
2380         }
2381         szAcl++;
2382     }
2383
2384     *StringAcl = szAcl;
2385     return flags;
2386 }
2387
2388 /******************************************************************************
2389  * ParseAceStringType
2390  */
2391 ACEFLAG AceType[] =
2392 {
2393     { SDDL_ACCESS_ALLOWED, ACCESS_ALLOWED_ACE_TYPE },
2394     { SDDL_ALARM,          SYSTEM_ALARM_ACE_TYPE },
2395     { SDDL_AUDIT,          SYSTEM_AUDIT_ACE_TYPE },
2396     { SDDL_ACCESS_DENIED,  ACCESS_DENIED_ACE_TYPE },
2397     /*
2398     { SDDL_OBJECT_ACCESS_ALLOWED, ACCESS_ALLOWED_OBJECT_ACE_TYPE },
2399     { SDDL_OBJECT_ACCESS_DENIED,  ACCESS_DENIED_OBJECT_ACE_TYPE },
2400     { SDDL_OBJECT_ALARM,          SYSTEM_ALARM_OBJECT_ACE_TYPE },
2401     { SDDL_OBJECT_AUDIT,          SYSTEM_AUDIT_OBJECT_ACE_TYPE },
2402     */
2403     { NULL, 0 },
2404 };
2405
2406 static BYTE ParseAceStringType(LPCWSTR* StringAcl)
2407 {
2408     UINT len = 0;
2409     LPCWSTR szAcl = *StringAcl;
2410     LPACEFLAG lpaf = AceType;
2411
2412     while (lpaf->wstr &&
2413         (len = strlenW(lpaf->wstr)) &&
2414         strncmpW(lpaf->wstr, szAcl, len))
2415         lpaf++;
2416
2417     if (!lpaf->wstr)
2418         return 0;
2419
2420     *StringAcl += len;
2421     return lpaf->value;
2422 }
2423
2424
2425 /******************************************************************************
2426  * ParseAceStringFlags
2427  */
2428 ACEFLAG AceFlags[] =
2429 {
2430     { SDDL_CONTAINER_INHERIT, CONTAINER_INHERIT_ACE },
2431     { SDDL_AUDIT_FAILURE,     FAILED_ACCESS_ACE_FLAG },
2432     { SDDL_INHERITED,         INHERITED_ACE },
2433     { SDDL_INHERIT_ONLY,      INHERIT_ONLY_ACE },
2434     { SDDL_NO_PROPAGATE,      NO_PROPAGATE_INHERIT_ACE },
2435     { SDDL_OBJECT_INHERIT,    OBJECT_INHERIT_ACE },
2436     { SDDL_AUDIT_SUCCESS,     SUCCESSFUL_ACCESS_ACE_FLAG },
2437     { NULL, 0 },
2438 };
2439
2440 static BYTE ParseAceStringFlags(LPCWSTR* StringAcl)
2441 {
2442     UINT len = 0;
2443     BYTE flags = 0;
2444     LPCWSTR szAcl = *StringAcl;
2445
2446     while (*szAcl != ';')
2447     {
2448         LPACEFLAG lpaf = AceFlags;
2449
2450         while (lpaf->wstr &&
2451                (len = strlenW(lpaf->wstr)) &&
2452                strncmpW(lpaf->wstr, szAcl, len))
2453             lpaf++;
2454
2455         if (!lpaf->wstr)
2456             return 0;
2457
2458         flags |= lpaf->value;
2459         szAcl += len;
2460     }
2461
2462     *StringAcl = szAcl;
2463     return flags;
2464 }
2465
2466
2467 /******************************************************************************
2468  * ParseAceStringRights
2469  */
2470 ACEFLAG AceRights[] =
2471 {
2472     { SDDL_GENERIC_ALL,     GENERIC_ALL },
2473     { SDDL_GENERIC_READ,    GENERIC_READ },
2474     { SDDL_GENERIC_WRITE,   GENERIC_WRITE },
2475     { SDDL_GENERIC_EXECUTE, GENERIC_EXECUTE },
2476     { SDDL_READ_CONTROL,    READ_CONTROL },
2477     { SDDL_STANDARD_DELETE, DELETE },
2478     { SDDL_WRITE_DAC,       WRITE_DAC },
2479     { SDDL_WRITE_OWNER,     WRITE_OWNER },
2480     { NULL, 0 },
2481 };
2482
2483 static DWORD ParseAceStringRights(LPCWSTR* StringAcl)
2484 {
2485     UINT len = 0;
2486     DWORD rights = 0;
2487     LPCWSTR szAcl = *StringAcl;
2488
2489     if ((*szAcl == '0') && (*(szAcl + 1) == 'x'))
2490     {
2491         LPCWSTR p = szAcl;
2492
2493         while (*p && *p != ';')
2494             p++;
2495
2496         if (p - szAcl <= 8)
2497         {
2498             rights = strtoulW(szAcl, NULL, 16);
2499             *StringAcl = p;
2500         }
2501         else
2502             WARN("Invalid rights string format: %s\n", debugstr_wn(szAcl, p - szAcl));
2503     }
2504     else
2505     {
2506         while (*szAcl != ';')
2507         {
2508             LPACEFLAG lpaf = AceRights;
2509
2510             while (lpaf->wstr &&
2511                (len = strlenW(lpaf->wstr)) &&
2512                strncmpW(lpaf->wstr, szAcl, len))
2513             {
2514                lpaf++;
2515             }
2516
2517             if (!lpaf->wstr)
2518                 return 0;
2519
2520             rights |= lpaf->value;
2521             szAcl += len;
2522         }
2523     }
2524
2525     *StringAcl = szAcl;
2526     return rights;
2527 }
2528
2529
2530 /******************************************************************************
2531  * ParseStringAclToAcl
2532  *
2533  * dacl_flags(string_ace1)(string_ace2)... (string_acen)
2534  */
2535 static BOOL ParseStringAclToAcl(LPCWSTR StringAcl, LPDWORD lpdwFlags,
2536     PACL pAcl, LPDWORD cBytes)
2537 {
2538     DWORD val;
2539     DWORD sidlen;
2540     DWORD length = sizeof(ACL);
2541     PACCESS_ALLOWED_ACE pAce = NULL; /* pointer to current ACE */
2542
2543     TRACE("%s\n", debugstr_w(StringAcl));
2544
2545     if (!StringAcl)
2546         return FALSE;
2547
2548     if (pAcl) /* pAce is only useful if we're setting values */
2549         pAce = (PACCESS_ALLOWED_ACE) ((LPBYTE)pAcl + sizeof(PACL));
2550
2551     /* Parse ACL flags */
2552     *lpdwFlags = ParseAclStringFlags(&StringAcl);
2553
2554     /* Parse ACE */
2555     while (*StringAcl == '(')
2556     {
2557         StringAcl++;
2558
2559         /* Parse ACE type */
2560         val = ParseAceStringType(&StringAcl);
2561         if (pAce)
2562             pAce->Header.AceType = (BYTE) val;
2563         if (*StringAcl != ';')
2564             goto lerr;
2565         StringAcl++;
2566
2567         /* Parse ACE flags */
2568         val = ParseAceStringFlags(&StringAcl);
2569         if (pAce)
2570             pAce->Header.AceFlags = (BYTE) val;
2571         if (*StringAcl != ';')
2572             goto lerr;
2573         StringAcl++;
2574
2575         /* Parse ACE rights */
2576         val = ParseAceStringRights(&StringAcl);
2577         if (pAce)
2578             pAce->Mask = val;
2579         if (*StringAcl != ';')
2580             goto lerr;
2581         StringAcl++;
2582
2583         /* Parse ACE object guid */
2584         if (*StringAcl != ';')
2585         {
2586             FIXME("Support for *_OBJECT_ACE_TYPE not implemented\n");
2587             goto lerr;
2588         }
2589         StringAcl++;
2590
2591         /* Parse ACE inherit object guid */
2592         if (*StringAcl != ';')
2593         {
2594             FIXME("Support for *_OBJECT_ACE_TYPE not implemented\n");
2595             goto lerr;
2596         }
2597         StringAcl++;
2598
2599         /* Parse ACE account sid */
2600         if (ParseStringSidToSid(StringAcl, pAce ? (PSID)&pAce->SidStart : NULL, &sidlen))
2601         {
2602             while (*StringAcl && *StringAcl != ')')
2603                 StringAcl++;
2604         }
2605
2606         if (*StringAcl != ')')
2607             goto lerr;
2608         StringAcl++;
2609
2610         length += sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + sidlen;
2611     }
2612
2613     *cBytes = length;
2614     return TRUE;
2615
2616 lerr:
2617     WARN("Invalid ACE string format\n");
2618     return FALSE;
2619 }
2620
2621
2622 /******************************************************************************
2623  * ParseStringSecurityDescriptorToSecurityDescriptor
2624  */
2625 static BOOL ParseStringSecurityDescriptorToSecurityDescriptor(
2626     LPCWSTR StringSecurityDescriptor,
2627     SECURITY_DESCRIPTOR* SecurityDescriptor,
2628     LPDWORD cBytes)
2629 {
2630     BOOL bret = FALSE;
2631     WCHAR toktype;
2632     WCHAR tok[MAX_PATH];
2633     LPCWSTR lptoken;
2634     LPBYTE lpNext = NULL;
2635     DWORD len;
2636
2637     *cBytes = 0;
2638
2639     if (SecurityDescriptor)
2640         lpNext = ((LPBYTE) SecurityDescriptor) + sizeof(SECURITY_DESCRIPTOR);
2641
2642     while (*StringSecurityDescriptor)
2643     {
2644         toktype = *StringSecurityDescriptor;
2645
2646         /* Expect char identifier followed by ':' */
2647         StringSecurityDescriptor++;
2648         if (*StringSecurityDescriptor != ':')
2649         {
2650             SetLastError(ERROR_INVALID_PARAMETER);
2651             goto lend;
2652         }
2653         StringSecurityDescriptor++;
2654
2655         /* Extract token */
2656         lptoken = StringSecurityDescriptor;
2657         while (*lptoken && *lptoken != ':')
2658             lptoken++;
2659
2660         if (*lptoken)
2661             lptoken--;
2662
2663         len = lptoken - StringSecurityDescriptor;
2664         memcpy( tok, StringSecurityDescriptor, len * sizeof(WCHAR) );
2665         tok[len] = 0;
2666
2667         switch (toktype)
2668         {
2669             case 'O':
2670             {
2671                 DWORD bytes;
2672
2673                 if (!ParseStringSidToSid(tok, (PSID)lpNext, &bytes))
2674                     goto lend;
2675
2676                 if (SecurityDescriptor)
2677                 {
2678                     SecurityDescriptor->Owner = (PSID)(lpNext - (LPBYTE)SecurityDescriptor);
2679                     lpNext += bytes; /* Advance to next token */
2680                 }
2681
2682                 *cBytes += bytes;
2683
2684                 break;
2685             }
2686
2687             case 'G':
2688             {
2689                 DWORD bytes;
2690
2691                 if (!ParseStringSidToSid(tok, (PSID)lpNext, &bytes))
2692                     goto lend;
2693
2694                 if (SecurityDescriptor)
2695                 {
2696                     SecurityDescriptor->Group = (PSID)(lpNext - (LPBYTE)SecurityDescriptor);
2697                     lpNext += bytes; /* Advance to next token */
2698                 }
2699
2700                 *cBytes += bytes;
2701
2702                 break;
2703             }
2704
2705             case 'D':
2706             {
2707                 DWORD flags;
2708                 DWORD bytes;
2709
2710                 if (!ParseStringAclToAcl(tok, &flags, (PACL)lpNext, &bytes))
2711                     goto lend;
2712
2713                 if (SecurityDescriptor)
2714                 {
2715                     SecurityDescriptor->Control |= SE_DACL_PRESENT | flags;
2716                     SecurityDescriptor->Dacl = (PACL)(lpNext - (LPBYTE)SecurityDescriptor);
2717                     lpNext += bytes; /* Advance to next token */
2718                 }
2719
2720                 *cBytes += bytes;
2721
2722                 break;
2723             }
2724
2725             case 'S':
2726             {
2727                 DWORD flags;
2728                 DWORD bytes;
2729
2730                 if (!ParseStringAclToAcl(tok, &flags, (PACL)lpNext, &bytes))
2731                     goto lend;
2732
2733                 if (SecurityDescriptor)
2734                 {
2735                     SecurityDescriptor->Control |= SE_SACL_PRESENT | flags;
2736                     SecurityDescriptor->Sacl = (PACL)(lpNext - (LPBYTE)SecurityDescriptor);
2737                     lpNext += bytes; /* Advance to next token */
2738                 }
2739
2740                 *cBytes += bytes;
2741
2742                 break;
2743             }
2744
2745             default:
2746                 FIXME("Unknown token\n");
2747                 SetLastError(ERROR_INVALID_PARAMETER);
2748                 goto lend;
2749         }
2750
2751         StringSecurityDescriptor = lptoken;
2752     }
2753
2754     bret = TRUE;
2755
2756 lend:
2757     return bret;
2758 }
2759
2760 /******************************************************************************
2761  * ConvertStringSecurityDescriptorToSecurityDescriptorA [ADVAPI32.@]
2762  */
2763 BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorA(
2764         LPCSTR StringSecurityDescriptor,
2765         DWORD StringSDRevision,
2766         PSECURITY_DESCRIPTOR* SecurityDescriptor,
2767         PULONG SecurityDescriptorSize)
2768 {
2769     UINT len;
2770     BOOL ret = FALSE;
2771     LPWSTR StringSecurityDescriptorW;
2772
2773     len = MultiByteToWideChar(CP_ACP, 0, StringSecurityDescriptor, -1, NULL, 0);
2774     StringSecurityDescriptorW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2775
2776     if (StringSecurityDescriptorW)
2777     {
2778         MultiByteToWideChar(CP_ACP, 0, StringSecurityDescriptor, -1, StringSecurityDescriptorW, len);
2779
2780         ret = ConvertStringSecurityDescriptorToSecurityDescriptorW(StringSecurityDescriptorW,
2781                                                                    StringSDRevision, SecurityDescriptor,
2782                                                                    SecurityDescriptorSize);
2783         HeapFree(GetProcessHeap(), 0, StringSecurityDescriptorW);
2784     }
2785
2786     return ret;
2787 }
2788
2789 /******************************************************************************
2790  * ConvertStringSecurityDescriptorToSecurityDescriptorW [ADVAPI32.@]
2791  */
2792 BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorW(
2793         LPCWSTR StringSecurityDescriptor,
2794         DWORD StringSDRevision,
2795         PSECURITY_DESCRIPTOR* SecurityDescriptor,
2796         PULONG SecurityDescriptorSize)
2797 {
2798     DWORD cBytes;
2799     SECURITY_DESCRIPTOR* psd;
2800     BOOL bret = FALSE;
2801
2802     TRACE("%s\n", debugstr_w(StringSecurityDescriptor));
2803
2804     if (GetVersion() & 0x80000000)
2805     {
2806         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2807         goto lend;
2808     }
2809     else if (StringSDRevision != SID_REVISION)
2810     {
2811         SetLastError(ERROR_UNKNOWN_REVISION);
2812         goto lend;
2813     }
2814
2815     /* Compute security descriptor length */
2816     if (!ParseStringSecurityDescriptorToSecurityDescriptor(StringSecurityDescriptor,
2817         NULL, &cBytes))
2818         goto lend;
2819
2820     psd = *SecurityDescriptor = (SECURITY_DESCRIPTOR*) LocalAlloc(
2821         GMEM_ZEROINIT, cBytes);
2822
2823     psd->Revision = SID_REVISION;
2824     psd->Control |= SE_SELF_RELATIVE;
2825
2826     if (!ParseStringSecurityDescriptorToSecurityDescriptor(StringSecurityDescriptor,
2827         psd, &cBytes))
2828     {
2829         LocalFree(psd);
2830         goto lend;
2831     }
2832
2833     if (SecurityDescriptorSize)
2834         *SecurityDescriptorSize = cBytes;
2835
2836     bret = TRUE;
2837
2838 lend:
2839     TRACE(" ret=%d\n", bret);
2840     return bret;
2841 }
2842
2843 /******************************************************************************
2844  * ConvertStringSidToSidW [ADVAPI32.@]
2845  */
2846 BOOL WINAPI ConvertStringSidToSidW(LPCWSTR StringSid, PSID* Sid)
2847 {
2848     BOOL bret = FALSE;
2849     DWORD cBytes;
2850
2851     TRACE("%s, %p\n", debugstr_w(StringSid), Sid);
2852     if (GetVersion() & 0x80000000)
2853         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2854     else if (!StringSid || !Sid)
2855         SetLastError(ERROR_INVALID_PARAMETER);
2856     else if (ParseStringSidToSid(StringSid, NULL, &cBytes))
2857     {
2858         PSID pSid = *Sid = (PSID) LocalAlloc(0, cBytes);
2859
2860         bret = ParseStringSidToSid(StringSid, pSid, &cBytes);
2861         if (!bret)
2862             LocalFree(*Sid);
2863     }
2864     TRACE("returning %s\n", bret ? "TRUE" : "FALSE");
2865     return bret;
2866 }
2867
2868 /******************************************************************************
2869  * ConvertStringSidToSidA [ADVAPI32.@]
2870  */
2871 BOOL WINAPI ConvertStringSidToSidA(LPCSTR StringSid, PSID* Sid)
2872 {
2873     BOOL bret = FALSE;
2874
2875     TRACE("%s, %p\n", debugstr_a(StringSid), Sid);
2876     if (GetVersion() & 0x80000000)
2877         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2878     else if (!StringSid || !Sid)
2879         SetLastError(ERROR_INVALID_PARAMETER);
2880     else
2881     {
2882         UINT len = MultiByteToWideChar(CP_ACP, 0, StringSid, -1, NULL, 0);
2883         LPWSTR wStringSid = HeapAlloc(GetProcessHeap(), 0,
2884          len * sizeof(WCHAR));
2885
2886         MultiByteToWideChar(CP_ACP, 0, StringSid, -1, wStringSid, len);
2887         bret = ConvertStringSidToSidW(wStringSid, Sid);
2888         HeapFree(GetProcessHeap(), 0, wStringSid);
2889     }
2890     TRACE("returning %s\n", bret ? "TRUE" : "FALSE");
2891     return bret;
2892 }
2893
2894 /******************************************************************************
2895  * ConvertSidToStringSidW [ADVAPI32.@]
2896  *
2897  *  format of SID string is:
2898  *    S-<count>-<auth>-<subauth1>-<subauth2>-<subauth3>...
2899  *  where
2900  *    <rev> is the revision of the SID encoded as decimal
2901  *    <auth> is the identifier authority encoded as hex
2902  *    <subauthN> is the subauthority id encoded as decimal
2903  */
2904 BOOL WINAPI ConvertSidToStringSidW( PSID pSid, LPWSTR *pstr )
2905 {
2906     DWORD sz, i;
2907     LPWSTR str;
2908     WCHAR fmt[] = { 'S','-','%','u','-','%','d',0 };
2909     WCHAR subauthfmt[] = { '-','%','u',0 };
2910     SID* pisid=pSid;
2911
2912     TRACE("%p %p\n", pSid, pstr );
2913
2914     if( !IsValidSid( pSid ) )
2915         return FALSE;
2916
2917     if (pisid->Revision != SDDL_REVISION)
2918         return FALSE;
2919     if (pisid->IdentifierAuthority.Value[0] ||
2920      pisid->IdentifierAuthority.Value[1])
2921     {
2922         FIXME("not matching MS' bugs\n");
2923         return FALSE;
2924     }
2925
2926     sz = 14 + pisid->SubAuthorityCount * 11;
2927     str = LocalAlloc( 0, sz*sizeof(WCHAR) );
2928     sprintfW( str, fmt, pisid->Revision, MAKELONG(
2929      MAKEWORD( pisid->IdentifierAuthority.Value[5],
2930      pisid->IdentifierAuthority.Value[4] ),
2931      MAKEWORD( pisid->IdentifierAuthority.Value[3],
2932      pisid->IdentifierAuthority.Value[2] ) ) );
2933     for( i=0; i<pisid->SubAuthorityCount; i++ )
2934         sprintfW( str + strlenW(str), subauthfmt, pisid->SubAuthority[i] );
2935     *pstr = str;
2936
2937     return TRUE;
2938 }
2939
2940 /******************************************************************************
2941  * ConvertSidToStringSidA [ADVAPI32.@]
2942  */
2943 BOOL WINAPI ConvertSidToStringSidA(PSID pSid, LPSTR *pstr)
2944 {
2945     LPWSTR wstr = NULL;
2946     LPSTR str;
2947     UINT len;
2948
2949     TRACE("%p %p\n", pSid, pstr );
2950
2951     if( !ConvertSidToStringSidW( pSid, &wstr ) )
2952         return FALSE;
2953
2954     len = WideCharToMultiByte( CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL );
2955     str = LocalAlloc( 0, len );
2956     WideCharToMultiByte( CP_ACP, 0, wstr, -1, str, len, NULL, NULL );
2957     LocalFree( wstr );
2958
2959     *pstr = str;
2960
2961     return TRUE;
2962 }
2963
2964 BOOL WINAPI CreatePrivateObjectSecurity(
2965         PSECURITY_DESCRIPTOR ParentDescriptor,
2966         PSECURITY_DESCRIPTOR CreatorDescriptor,
2967         PSECURITY_DESCRIPTOR* NewDescriptor,
2968         BOOL IsDirectoryObject,
2969         HANDLE Token,
2970         PGENERIC_MAPPING GenericMapping )
2971 {
2972     FIXME("%p %p %p %d %p %p - stub\n", ParentDescriptor, CreatorDescriptor,
2973           NewDescriptor, IsDirectoryObject, Token, GenericMapping);
2974
2975     return FALSE;
2976 }
2977
2978 BOOL WINAPI DestroyPrivateObjectSecurity( PSECURITY_DESCRIPTOR* ObjectDescriptor )
2979 {
2980     FIXME("%p - stub\n", ObjectDescriptor);
2981
2982     return TRUE;
2983 }
2984
2985 BOOL WINAPI CreateProcessAsUserA(
2986         HANDLE hToken,
2987         LPCSTR lpApplicationName,
2988         LPSTR lpCommandLine,
2989         LPSECURITY_ATTRIBUTES lpProcessAttributes,
2990         LPSECURITY_ATTRIBUTES lpThreadAttributes,
2991         BOOL bInheritHandles,
2992         DWORD dwCreationFlags,
2993         LPVOID lpEnvironment,
2994         LPCSTR lpCurrentDirectory,
2995         LPSTARTUPINFOA lpStartupInfo,
2996         LPPROCESS_INFORMATION lpProcessInformation )
2997 {
2998     FIXME("%p %s %s %p %p %d 0x%08lx %p %s %p %p - stub\n", hToken, debugstr_a(lpApplicationName),
2999           debugstr_a(lpCommandLine), lpProcessAttributes, lpThreadAttributes, bInheritHandles,
3000           dwCreationFlags, lpEnvironment, debugstr_a(lpCurrentDirectory), lpStartupInfo, lpProcessInformation);
3001
3002     return FALSE;
3003 }
3004
3005 BOOL WINAPI CreateProcessAsUserW(
3006         HANDLE hToken,
3007         LPCWSTR lpApplicationName,
3008         LPWSTR lpCommandLine,
3009         LPSECURITY_ATTRIBUTES lpProcessAttributes,
3010         LPSECURITY_ATTRIBUTES lpThreadAttributes,
3011         BOOL bInheritHandles,
3012         DWORD dwCreationFlags,
3013         LPVOID lpEnvironment,
3014         LPCWSTR lpCurrentDirectory,
3015         LPSTARTUPINFOW lpStartupInfo,
3016         LPPROCESS_INFORMATION lpProcessInformation )
3017 {
3018     FIXME("%p %s %s %p %p %d 0x%08lx %p %s %p %p - semi- stub\n", hToken,
3019           debugstr_w(lpApplicationName), debugstr_w(lpCommandLine), lpProcessAttributes,
3020           lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment,
3021           debugstr_w(lpCurrentDirectory), lpStartupInfo, lpProcessInformation);
3022
3023     /* We should create the process with a suspended main thread */
3024     if (!CreateProcessW (lpApplicationName,
3025                          lpCommandLine,
3026                          lpProcessAttributes,
3027                          lpThreadAttributes,
3028                          bInheritHandles,
3029                          dwCreationFlags, /* CREATE_SUSPENDED */
3030                          lpEnvironment,
3031                          lpCurrentDirectory,
3032                          lpStartupInfo,
3033                          lpProcessInformation))
3034     {
3035       return FALSE;
3036     }
3037
3038     return TRUE;
3039 }
3040
3041 /******************************************************************************
3042  * ComputeStringSidSize
3043  */
3044 static DWORD ComputeStringSidSize(LPCWSTR StringSid)
3045 {
3046     int ctok = 0;
3047     DWORD size = sizeof(SID);
3048
3049     while (*StringSid)
3050     {
3051         if (*StringSid == '-')
3052             ctok++;
3053         StringSid++;
3054     }
3055
3056     if (ctok > 3)
3057         size += (ctok - 3) * sizeof(DWORD);
3058
3059     return size;
3060 }
3061
3062 BOOL WINAPI DuplicateTokenEx(
3063         HANDLE ExistingTokenHandle, DWORD dwDesiredAccess,
3064         LPSECURITY_ATTRIBUTES lpTokenAttributes,
3065         SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
3066         TOKEN_TYPE TokenType,
3067         PHANDLE DuplicateTokenHandle )
3068 {
3069     OBJECT_ATTRIBUTES ObjectAttributes;
3070
3071     TRACE("%p 0x%08lx 0x%08x 0x%08x %p\n", ExistingTokenHandle, dwDesiredAccess,
3072           ImpersonationLevel, TokenType, DuplicateTokenHandle);
3073
3074     InitializeObjectAttributes(
3075         &ObjectAttributes,
3076         NULL,
3077         (lpTokenAttributes && lpTokenAttributes->bInheritHandle) ? OBJ_INHERIT : 0,
3078         NULL,
3079         lpTokenAttributes ? lpTokenAttributes->lpSecurityDescriptor : NULL );
3080
3081     return set_ntstatus( NtDuplicateToken( ExistingTokenHandle,
3082                                            dwDesiredAccess,
3083                                            &ObjectAttributes,
3084                                            ImpersonationLevel,
3085                                            TokenType,
3086                                            DuplicateTokenHandle ) );
3087 }
3088
3089 BOOL WINAPI DuplicateToken(
3090         HANDLE ExistingTokenHandle,
3091         SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
3092         PHANDLE DuplicateTokenHandle )
3093 {
3094     return DuplicateTokenEx( ExistingTokenHandle, TOKEN_IMPERSONATE | TOKEN_QUERY,
3095                              NULL, ImpersonationLevel, TokenImpersonation,
3096                              DuplicateTokenHandle );
3097 }
3098
3099 BOOL WINAPI EnumDependentServicesA(
3100         SC_HANDLE hService,
3101         DWORD dwServiceState,
3102         LPENUM_SERVICE_STATUSA lpServices,
3103         DWORD cbBufSize,
3104         LPDWORD pcbBytesNeeded,
3105         LPDWORD lpServicesReturned )
3106 {
3107     FIXME("%p 0x%08lx %p 0x%08lx %p %p - stub\n", hService, dwServiceState,
3108           lpServices, cbBufSize, pcbBytesNeeded, lpServicesReturned);
3109
3110     return FALSE;
3111 }
3112
3113 BOOL WINAPI EnumDependentServicesW(
3114         SC_HANDLE hService,
3115         DWORD dwServiceState,
3116         LPENUM_SERVICE_STATUSW lpServices,
3117         DWORD cbBufSize,
3118         LPDWORD pcbBytesNeeded,
3119         LPDWORD lpServicesReturned )
3120 {
3121     FIXME("%p 0x%08lx %p 0x%08lx %p %p - stub\n", hService, dwServiceState,
3122           lpServices, cbBufSize, pcbBytesNeeded, lpServicesReturned);
3123
3124     return FALSE;
3125 }
3126
3127 /******************************************************************************
3128  * ParseStringSidToSid
3129  */
3130 static BOOL ParseStringSidToSid(LPCWSTR StringSid, PSID pSid, LPDWORD cBytes)
3131 {
3132     BOOL bret = FALSE;
3133     SID* pisid=pSid;
3134
3135     TRACE("%s, %p, %p\n", debugstr_w(StringSid), pSid, cBytes);
3136     if (!StringSid)
3137     {
3138         SetLastError(ERROR_INVALID_PARAMETER);
3139         TRACE("StringSid is NULL, returning FALSE\n");
3140         return FALSE;
3141     }
3142
3143     *cBytes = ComputeStringSidSize(StringSid);
3144     if (!pisid) /* Simply compute the size */
3145     {
3146         TRACE("only size requested, returning TRUE\n");
3147         return TRUE;
3148     }
3149
3150     if (StringSid[0] == 'S' && StringSid[1] == '-') /* S-R-I-S-S */
3151     {
3152         DWORD i = 0, identAuth;
3153         DWORD csubauth = ((*cBytes - sizeof(SID)) / sizeof(DWORD)) + 1;
3154
3155         StringSid += 2; /* Advance to Revision */
3156         pisid->Revision = atoiW(StringSid);
3157
3158         if (pisid->Revision != SDDL_REVISION)
3159         {
3160             TRACE("Revision %d is unknown\n", pisid->Revision);
3161             goto lend; /* ERROR_INVALID_SID */
3162         }
3163         if (csubauth == 0)
3164         {
3165             TRACE("SubAuthorityCount is 0\n");
3166             goto lend; /* ERROR_INVALID_SID */
3167         }
3168
3169         pisid->SubAuthorityCount = csubauth;
3170
3171         /* Advance to identifier authority */
3172         while (*StringSid && *StringSid != '-')
3173             StringSid++;
3174         if (*StringSid == '-')
3175             StringSid++;
3176
3177         /* MS' implementation can't handle values greater than 2^32 - 1, so
3178          * we don't either; assume most significant bytes are always 0
3179          */
3180         pisid->IdentifierAuthority.Value[0] = 0;
3181         pisid->IdentifierAuthority.Value[1] = 0;
3182         identAuth = atoiW(StringSid);
3183         pisid->IdentifierAuthority.Value[5] = identAuth & 0xff;
3184         pisid->IdentifierAuthority.Value[4] = (identAuth & 0xff00) >> 8;
3185         pisid->IdentifierAuthority.Value[3] = (identAuth & 0xff0000) >> 16;
3186         pisid->IdentifierAuthority.Value[2] = (identAuth & 0xff000000) >> 24;
3187
3188         /* Advance to first sub authority */
3189         while (*StringSid && *StringSid != '-')
3190             StringSid++;
3191         if (*StringSid == '-')
3192             StringSid++;
3193
3194         while (*StringSid)
3195         {
3196             while (*StringSid && *StringSid != '-')
3197                 StringSid++;
3198
3199             pisid->SubAuthority[i++] = atoiW(StringSid);
3200         }
3201
3202         if (i != pisid->SubAuthorityCount)
3203             goto lend; /* ERROR_INVALID_SID */
3204
3205         bret = TRUE;
3206     }
3207     else /* String constant format  - Only available in winxp and above */
3208     {
3209         pisid->Revision = SDDL_REVISION;
3210         pisid->SubAuthorityCount = 1;
3211
3212         FIXME("String constant not supported: %s\n", debugstr_wn(StringSid, 2));
3213
3214         /* TODO: Lookup string of well-known SIDs in table */
3215         pisid->IdentifierAuthority.Value[5] = 0;
3216         pisid->SubAuthority[0] = 0;
3217
3218         bret = TRUE;
3219     }
3220
3221 lend:
3222     if (!bret)
3223         SetLastError(ERROR_INVALID_SID);
3224
3225     TRACE("returning %s\n", bret ? "TRUE" : "FALSE");
3226     return bret;
3227 }
3228
3229 /******************************************************************************
3230  * GetNamedSecurityInfoA [ADVAPI32.@]
3231  */
3232 DWORD WINAPI GetNamedSecurityInfoA(LPSTR pObjectName,
3233         SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo,
3234         PSID* ppsidOwner, PSID* ppsidGroup, PACL* ppDacl, PACL* ppSacl,
3235         PSECURITY_DESCRIPTOR* ppSecurityDescriptor)
3236 {
3237     DWORD len;
3238     LPWSTR wstr = NULL;
3239     DWORD r;
3240
3241     TRACE("%s %d %ld %p %p %p %p %p\n", pObjectName, ObjectType, SecurityInfo,
3242         ppsidOwner, ppsidGroup, ppDacl, ppSacl, ppSecurityDescriptor);
3243
3244     if( pObjectName )
3245     {
3246         len = MultiByteToWideChar( CP_ACP, 0, pObjectName, -1, NULL, 0 );
3247         wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR));
3248         MultiByteToWideChar( CP_ACP, 0, pObjectName, -1, wstr, len );
3249     }
3250
3251     r = GetNamedSecurityInfoW( wstr, ObjectType, SecurityInfo, ppsidOwner,
3252                            ppsidGroup, ppDacl, ppSacl, ppSecurityDescriptor );
3253
3254     HeapFree( GetProcessHeap(), 0, wstr );
3255
3256     return r;
3257 }
3258
3259 /******************************************************************************
3260  * GetNamedSecurityInfoW [ADVAPI32.@]
3261  */
3262 DWORD WINAPI GetNamedSecurityInfoW( LPWSTR name, SE_OBJECT_TYPE type,
3263     SECURITY_INFORMATION info, PSID* owner, PSID* group, PACL* dacl,
3264     PACL* sacl, PSECURITY_DESCRIPTOR* descriptor )
3265 {
3266     DWORD needed, offset;
3267     SECURITY_DESCRIPTOR_RELATIVE *relative;
3268     BYTE *buffer;
3269
3270     TRACE( "%s %d %ld %p %p %p %p %p\n", debugstr_w(name), type, info, owner,
3271            group, dacl, sacl, descriptor );
3272
3273     if (!name || !descriptor) return ERROR_INVALID_PARAMETER;
3274
3275     needed = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
3276     if (info & OWNER_SECURITY_INFORMATION)
3277         needed += sizeof(sidWorld);
3278     if (info & GROUP_SECURITY_INFORMATION)
3279         needed += sizeof(sidWorld);
3280     if (info & DACL_SECURITY_INFORMATION)
3281         needed += WINE_SIZE_OF_WORLD_ACCESS_ACL;
3282     if (info & SACL_SECURITY_INFORMATION)
3283         needed += WINE_SIZE_OF_WORLD_ACCESS_ACL;
3284
3285     /* must be freed by caller */
3286     *descriptor = HeapAlloc( GetProcessHeap(), 0, needed );
3287     if (!*descriptor) return ERROR_NOT_ENOUGH_MEMORY;
3288
3289     if (!InitializeSecurityDescriptor( *descriptor, SECURITY_DESCRIPTOR_REVISION ))
3290     {
3291         HeapFree( GetProcessHeap(), 0, *descriptor );
3292         return ERROR_INVALID_SECURITY_DESCR;
3293     }
3294
3295     relative = (SECURITY_DESCRIPTOR_RELATIVE *)*descriptor;
3296     relative->Control |= SE_SELF_RELATIVE;
3297     buffer = (BYTE *)relative;
3298     offset = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
3299
3300     if (owner && (info & OWNER_SECURITY_INFORMATION))
3301     {
3302         memcpy( buffer + offset, &sidWorld, sizeof(sidWorld) );
3303         relative->Owner = offset;
3304         *owner = buffer + offset;
3305         offset += sizeof(sidWorld);
3306     }
3307     if (group && (info & GROUP_SECURITY_INFORMATION))
3308     {
3309         memcpy( buffer + offset, &sidWorld, sizeof(sidWorld) );
3310         relative->Group = offset;
3311         *group = buffer + offset;
3312         offset += sizeof(sidWorld);
3313     }
3314     if (dacl && (info & DACL_SECURITY_INFORMATION))
3315     {
3316         GetWorldAccessACL( (PACL)(buffer + offset) );
3317         relative->Dacl = offset;
3318         *dacl = (PACL)(buffer + offset);
3319         offset += WINE_SIZE_OF_WORLD_ACCESS_ACL;
3320     }
3321     if (sacl && (info & SACL_SECURITY_INFORMATION))
3322     {
3323         GetWorldAccessACL( (PACL)(buffer + offset) );
3324         relative->Sacl = offset;
3325         *sacl = (PACL)(buffer + offset);
3326     }
3327     return ERROR_SUCCESS;
3328 }
3329
3330 /******************************************************************************
3331  * DecryptFileW [ADVAPI32.@]
3332  */
3333 BOOL WINAPI DecryptFileW(LPCWSTR lpFileName, DWORD dwReserved)
3334 {
3335     FIXME("%s %08lx\n", debugstr_w(lpFileName), dwReserved);
3336     return TRUE;
3337 }
3338
3339 /******************************************************************************
3340  * DecryptFileA [ADVAPI32.@]
3341  */
3342 BOOL WINAPI DecryptFileA(LPCSTR lpFileName, DWORD dwReserved)
3343 {
3344     FIXME("%s %08lx\n", debugstr_a(lpFileName), dwReserved);
3345     return TRUE;
3346 }
3347
3348 /******************************************************************************
3349  * EncryptFileW [ADVAPI32.@]
3350  */
3351 BOOL WINAPI EncryptFileW(LPCWSTR lpFileName)
3352 {
3353     FIXME("%s\n", debugstr_w(lpFileName));
3354     return TRUE;
3355 }
3356
3357 /******************************************************************************
3358  * EncryptFileA [ADVAPI32.@]
3359  */
3360 BOOL WINAPI EncryptFileA(LPCSTR lpFileName)
3361 {
3362     FIXME("%s\n", debugstr_a(lpFileName));
3363     return TRUE;
3364 }
3365
3366 /******************************************************************************
3367  * SetSecurityInfo [ADVAPI32.@]
3368  */
3369 DWORD WINAPI SetSecurityInfo(HANDLE handle, SE_OBJECT_TYPE ObjectType,
3370                       SECURITY_INFORMATION SecurityInfo, PSID psidOwner,
3371                       PSID psidGroup, PACL pDacl, PACL pSacl) {
3372     FIXME("stub\n");
3373     return ERROR_SUCCESS;
3374 }