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

   1 /*
   2  * Copyright 1999, 2000 Juergen Schmied <juergen.schmied@debitel.net>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  *
  18  *  FIXME: for all functions thunking down to Rtl* functions:  implement SetLastError()
  19  */
  20
  21 #include <string.h>
  22
  23 #include "windef.h"
  24 #include "winerror.h"
  25 #include "rpcnterr.h"
  26 #include "winternl.h"
  27 #include "ntsecapi.h"
  28 #include "accctrl.h"
  29
  30 #include "wine/debug.h"
  31 #include "wine/unicode.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
  34
  35 #define CallWin32ToNt(func) \
  36         { NTSTATUS ret; \
  37           ret = (func); \
  38           if (ret !=STATUS_SUCCESS) \
  39           { SetLastError (RtlNtStatusToDosError(ret)); return FALSE; } \
  40           return TRUE; \
  41         }
  42
  43 static void dumpLsaAttributes( PLSA_OBJECT_ATTRIBUTES oa )
  44 {
  45         if (oa)
  46         {
  47           TRACE("\n\tlength=%lu, rootdir=%p, objectname=%s\n\tattr=0x%08lx, sid=%p qos=%p\n",
  48                 oa->Length, oa->RootDirectory,
  49                 oa->ObjectName?debugstr_w(oa->ObjectName->Buffer):"null",
  50                 oa->Attributes, oa->SecurityDescriptor, oa->SecurityQualityOfService);
  51         }
  52 }
  53
  54 /************************************************************
  55  *                ADVAPI_IsLocalComputer
  56  *
  57  * Checks whether the server name indicates local machine.
  58  */
  59 BOOL ADVAPI_IsLocalComputer(LPCWSTR ServerName)
  60 {
  61     if (!ServerName)
  62     {
  63         return TRUE;
  64     }
  65     else
  66     {
  67         DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
  68         BOOL Result;
  69         LPWSTR buf;
  70
  71         buf = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
  72         Result = GetComputerNameW(buf,  &dwSize);
  73         if (Result && (ServerName[0] == '\\') && (ServerName[1] == '\\'))
  74             ServerName += 2;
  75         Result = Result && !lstrcmpW(ServerName, buf);
  76         HeapFree(GetProcessHeap(), 0, buf);
  77
  78         return Result;
  79     }
  80 }
  81
  82 #define ADVAPI_ForceLocalComputer(ServerName, FailureCode) \
  83     if (!ADVAPI_IsLocalComputer(ServerName)) \
  84     { \
  85         FIXME("Action Implemented for local computer only. " \
  86               "Requested for server %s\n", debugstr_w(ServerName)); \
  87         return FailureCode; \
  88     }
  89
  90 /*      ##############################
  91         ######  TOKEN FUNCTIONS ######
  92         ##############################
  93 */
  94
  95 /******************************************************************************
  96  * OpenProcessToken                     [ADVAPI32.@]
  97  * Opens the access token associated with a process handle.
  98  *
  99  * PARAMS
 100  *   ProcessHandle [I] Handle to process
 101  *   DesiredAccess [I] Desired access to process
 102  *   TokenHandle   [O] Pointer to handle of open access token
 103  *
 104  * RETURNS
 105  *  Success: TRUE. TokenHandle contains the access token.
 106  *  Failure: FALSE.
 107  *
 108  * NOTES
 109  *  See NtOpenProcessToken.
 110  */
 111 BOOL WINAPI
 112 OpenProcessToken( HANDLE ProcessHandle, DWORD DesiredAccess,
 113                   HANDLE *TokenHandle )
 114 {
 115         CallWin32ToNt(NtOpenProcessToken( ProcessHandle, DesiredAccess, TokenHandle ));
 116 }
 117
 118 /******************************************************************************
 119  * OpenThreadToken [ADVAPI32.@]
 120  *
 121  * Opens the access token associated with a thread handle.
 122  *
 123  * PARAMS
 124  *   ThreadHandle  [I] Handle to process
 125  *   DesiredAccess [I] Desired access to the thread
 126  *   OpenAsSelf    [I] ???
 127  *   TokenHandle   [O] Destination for the token handle
 128  *
 129  * RETURNS
 130  *  Success: TRUE. TokenHandle contains the access token.
 131  *  Failure: FALSE.
 132  *
 133  * NOTES
 134  *  See NtOpenThreadToken.
 135  */
 136 BOOL WINAPI
 137 OpenThreadToken( HANDLE ThreadHandle, DWORD DesiredAccess,
 138                  BOOL OpenAsSelf, HANDLE *TokenHandle)
 139 {
 140         CallWin32ToNt (NtOpenThreadToken(ThreadHandle, DesiredAccess, OpenAsSelf, TokenHandle));
 141 }
 142
 143 /******************************************************************************
 144  * AdjustTokenPrivileges [ADVAPI32.@]
 145  *
 146  * Adjust the privileges of an open token handle.
 147  *
 148  * PARAMS
 149  *  TokenHandle          [I]   Handle from OpenProcessToken() or OpenThreadToken()
 150  *  DisableAllPrivileges [I]   TRUE=Remove all privileges, FALSE=Use NewState
 151  *  NewState             [I]   Desired new privileges of the token
 152  *  BufferLength         [I]   Length of NewState
 153  *  PreviousState        [O]   Destination for the previous state
 154  *  ReturnLength         [I/O] Size of PreviousState
 155  *
 156  *
 157  * RETURNS
 158  *  Success: TRUE. Privileges are set to NewState and PreviousState is updated.
 159  *  Failure: FALSE.
 160  *
 161  * NOTES
 162  *  See NtAdjustPrivilegesToken.
 163  */
 164 BOOL WINAPI
 165 AdjustTokenPrivileges( HANDLE TokenHandle, BOOL DisableAllPrivileges,
 166                        LPVOID NewState, DWORD BufferLength,
 167                        LPVOID PreviousState, LPDWORD ReturnLength )
 168 {
 169         CallWin32ToNt(NtAdjustPrivilegesToken(TokenHandle, DisableAllPrivileges, NewState, BufferLength, PreviousState, ReturnLength));
 170 }
 171
 172 /******************************************************************************
 173  * CheckTokenMembership [ADVAPI32.@]
 174  *
 175  * Determine if an access token is a member of a SID.
 176  *
 177  * PARAMS
 178  *   TokenHandle [I] Handle from OpenProcessToken() or OpenThreadToken()
 179  *   SidToCheck  [I] SID that possibly contains the token
 180  *   IsMember    [O] Destination for result.
 181  *
 182  * RETURNS
 183  *  Success: TRUE. IsMember is TRUE if TokenHandle is a member, FALSE otherwise.
 184  *  Failure: FALSE.
 185  */
 186 BOOL WINAPI
 187 CheckTokenMembership( HANDLE TokenHandle, PSID SidToCheck,
 188                       PBOOL IsMember )
 189 {
 190   FIXME("(%p %p %p) stub!\n", TokenHandle, SidToCheck, IsMember);
 191
 192   *IsMember = TRUE;
 193   return(TRUE);
 194 }
 195
 196 /******************************************************************************
 197  * GetTokenInformation [ADVAPI32.@]
 198  *
 199  * PARAMS
 200  *   token           [I] Handle from OpenProcessToken() or OpenThreadToken()
 201  *   tokeninfoclass  [I] A TOKEN_INFORMATION_CLASS from "winnt.h"
 202  *   tokeninfo       [O] Destination for token information
 203  *   tokeninfolength [I] Length of tokeninfo
 204  *   retlen          [O] Destination for returned token information length
 205  *
 206  * RETURNS
 207  *  Success: TRUE. tokeninfo contains retlen bytes of token information
 208  *  Failure: FALSE.
 209  *
 210  * NOTES
 211  *  See NtQueryInformationToken.
 212  */
 213 BOOL WINAPI
 214 GetTokenInformation( HANDLE token, TOKEN_INFORMATION_CLASS tokeninfoclass,
 215                      LPVOID tokeninfo, DWORD tokeninfolength, LPDWORD retlen )
 216 {
 217     TRACE("(%p, %s, %p, %ld, %p): \n",
 218           token,
 219           (tokeninfoclass == TokenUser) ? "TokenUser" :
 220           (tokeninfoclass == TokenGroups) ? "TokenGroups" :
 221           (tokeninfoclass == TokenPrivileges) ? "TokenPrivileges" :
 222           (tokeninfoclass == TokenOwner) ? "TokenOwner" :
 223           (tokeninfoclass == TokenPrimaryGroup) ? "TokenPrimaryGroup" :
 224           (tokeninfoclass == TokenDefaultDacl) ? "TokenDefaultDacl" :
 225           (tokeninfoclass == TokenSource) ? "TokenSource" :
 226           (tokeninfoclass == TokenType) ? "TokenType" :
 227           (tokeninfoclass == TokenImpersonationLevel) ? "TokenImpersonationLevel" :
 228           (tokeninfoclass == TokenStatistics) ? "TokenStatistics" :
 229           (tokeninfoclass == TokenRestrictedSids) ? "TokenRestrictedSids" :
 230           (tokeninfoclass == TokenSessionId) ? "TokenSessionId" :
 231           (tokeninfoclass == TokenGroupsAndPrivileges) ? "TokenGroupsAndPrivileges" :
 232           (tokeninfoclass == TokenSessionReference) ? "TokenSessionReference" :
 233           (tokeninfoclass == TokenSandBoxInert) ? "TokenSandBoxInert" :
 234           "Unknown",
 235           tokeninfo, tokeninfolength, retlen);
 236     CallWin32ToNt (NtQueryInformationToken( token, tokeninfoclass, tokeninfo, tokeninfolength, retlen));
 237 }
 238
 239 /******************************************************************************
 240  * SetTokenInformation [ADVAPI32.@]
 241  *
 242  * Set information for an access token.
 243  *
 244  * PARAMS
 245  *   token           [I] Handle from OpenProcessToken() or OpenThreadToken()
 246  *   tokeninfoclass  [I] A TOKEN_INFORMATION_CLASS from "winnt.h"
 247  *   tokeninfo       [I] Token information to set
 248  *   tokeninfolength [I] Length of tokeninfo
 249  *
 250  * RETURNS
 251  *  Success: TRUE. The information for the token is set to tokeninfo.
 252  *  Failure: FALSE.
 253  */
 254 BOOL WINAPI
 255 SetTokenInformation( HANDLE token, TOKEN_INFORMATION_CLASS tokeninfoclass,
 256                      LPVOID tokeninfo, DWORD tokeninfolength )
 257 {
 258     FIXME("(%p, %s, %p, %ld): stub\n",
 259           token,
 260           (tokeninfoclass == TokenUser) ? "TokenUser" :
 261           (tokeninfoclass == TokenGroups) ? "TokenGroups" :
 262           (tokeninfoclass == TokenPrivileges) ? "TokenPrivileges" :
 263           (tokeninfoclass == TokenOwner) ? "TokenOwner" :
 264           (tokeninfoclass == TokenPrimaryGroup) ? "TokenPrimaryGroup" :
 265           (tokeninfoclass == TokenDefaultDacl) ? "TokenDefaultDacl" :
 266           (tokeninfoclass == TokenSource) ? "TokenSource" :
 267           (tokeninfoclass == TokenType) ? "TokenType" :
 268           (tokeninfoclass == TokenImpersonationLevel) ? "TokenImpersonationLevel" :
 269           (tokeninfoclass == TokenStatistics) ? "TokenStatistics" :
 270           (tokeninfoclass == TokenRestrictedSids) ? "TokenRestrictedSids" :
 271           (tokeninfoclass == TokenSessionId) ? "TokenSessionId" :
 272           (tokeninfoclass == TokenGroupsAndPrivileges) ? "TokenGroupsAndPrivileges" :
 273           (tokeninfoclass == TokenSessionReference) ? "TokenSessionReference" :
 274           (tokeninfoclass == TokenSandBoxInert) ? "TokenSandBoxInert" :
 275           "Unknown",
 276           tokeninfo, tokeninfolength);
 277
 278     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 279
 280     return FALSE;
 281 }
 282
 283 /*************************************************************************
 284  * SetThreadToken [ADVAPI32.@]
 285  *
 286  * Assigns an 'impersonation token' to a thread so it can assume the
 287  * security privledges of another thread or process.  Can also remove
 288  * a previously assigned token.
 289  *
 290  * PARAMS
 291  *   thread          [O] Handle to thread to set the token for
 292  *   token           [I] Token to set
 293  *
 294  * RETURNS
 295  *  Success: TRUE. The threads access token is set to token
 296  *  Failure: FALSE.
 297  *
 298  * NOTES
 299  *  Only supported on NT or higher. On Win9X this function does nothing.
 300  *  See SetTokenInformation.
 301  */
 302 BOOL WINAPI SetThreadToken(PHANDLE thread, HANDLE token)
 303 {
 304     FIXME("(%p, %p): stub (NT impl. only)\n", thread, token);
 305
 306     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 307
 308     return FALSE;
 309 }
 310
 311 /*      ##############################
 312         ######  SID FUNCTIONS   ######
 313         ##############################
 314 */
 315
 316 /******************************************************************************
 317  * AllocateAndInitializeSid [ADVAPI32.@]
 318  *
 319  * PARAMS
 320  *   pIdentifierAuthority []
 321  *   nSubAuthorityCount   []
 322  *   nSubAuthority0       []
 323  *   nSubAuthority1       []
 324  *   nSubAuthority2       []
 325  *   nSubAuthority3       []
 326  *   nSubAuthority4       []
 327  *   nSubAuthority5       []
 328  *   nSubAuthority6       []
 329  *   nSubAuthority7       []
 330  *   pSid                 []
 331  */
 332 BOOL WINAPI
 333 AllocateAndInitializeSid( PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
 334                           BYTE nSubAuthorityCount,
 335                           DWORD nSubAuthority0, DWORD nSubAuthority1,
 336                           DWORD nSubAuthority2, DWORD nSubAuthority3,
 337                           DWORD nSubAuthority4, DWORD nSubAuthority5,
 338                           DWORD nSubAuthority6, DWORD nSubAuthority7,
 339                           PSID *pSid )
 340 {
 341         CallWin32ToNt (RtlAllocateAndInitializeSid(
 342                 pIdentifierAuthority, nSubAuthorityCount,
 343                 nSubAuthority0, nSubAuthority1, nSubAuthority2, nSubAuthority3,
 344                 nSubAuthority4, nSubAuthority5, nSubAuthority6, nSubAuthority7,
 345                 pSid ));
 346 }
 347
 348 /******************************************************************************
 349  * FreeSid [ADVAPI32.@]
 350  *
 351  * PARAMS
 352  *   pSid []
 353  */
 354 PVOID WINAPI
 355 FreeSid( PSID pSid )
 356 {
 357         RtlFreeSid(pSid);
 358         return NULL; /* is documented like this */
 359 }
 360
 361 /******************************************************************************
 362  * CopySid [ADVAPI32.@]
 363  *
 364  * PARAMS
 365  *   nDestinationSidLength []
 366  *   pDestinationSid       []
 367  *   pSourceSid            []
 368  */
 369 BOOL WINAPI
 370 CopySid( DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid )
 371 {
 372         return RtlCopySid(nDestinationSidLength, pDestinationSid, pSourceSid);
 373 }
 374
 375 /******************************************************************************
 376  * IsValidSid [ADVAPI32.@]
 377  *
 378  * PARAMS
 379  *   pSid []
 380  */
 381 BOOL WINAPI
 382 IsValidSid( PSID pSid )
 383 {
 384         return RtlValidSid( pSid );
 385 }
 386
 387 /******************************************************************************
 388  * EqualSid [ADVAPI32.@]
 389  *
 390  * PARAMS
 391  *   pSid1 []
 392  *   pSid2 []
 393  */
 394 BOOL WINAPI
 395 EqualSid( PSID pSid1, PSID pSid2 )
 396 {
 397         return RtlEqualSid( pSid1, pSid2 );
 398 }
 399
 400 /******************************************************************************
 401  * EqualPrefixSid [ADVAPI32.@]
 402  */
 403 BOOL WINAPI EqualPrefixSid (PSID pSid1, PSID pSid2)
 404 {
 405         return RtlEqualPrefixSid(pSid1, pSid2);
 406 }
 407
 408 /******************************************************************************
 409  * GetSidLengthRequired [ADVAPI32.@]
 410  *
 411  * PARAMS
 412  *   nSubAuthorityCount []
 413  */
 414 DWORD WINAPI
 415 GetSidLengthRequired( BYTE nSubAuthorityCount )
 416 {
 417         return RtlLengthRequiredSid(nSubAuthorityCount);
 418 }
 419
 420 /******************************************************************************
 421  * InitializeSid [ADVAPI32.@]
 422  *
 423  * PARAMS
 424  *   pIdentifierAuthority []
 425  */
 426 BOOL WINAPI
 427 InitializeSid (
 428         PSID pSid,
 429         PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
 430         BYTE nSubAuthorityCount)
 431 {
 432         return RtlInitializeSid(pSid, pIdentifierAuthority, nSubAuthorityCount);
 433 }
 434
 435 /******************************************************************************
 436  * GetSidIdentifierAuthority [ADVAPI32.@]
 437  *
 438  * PARAMS
 439  *   pSid []
 440  */
 441 PSID_IDENTIFIER_AUTHORITY WINAPI
 442 GetSidIdentifierAuthority( PSID pSid )
 443 {
 444         return RtlIdentifierAuthoritySid(pSid);
 445 }
 446
 447 /******************************************************************************
 448  * GetSidSubAuthority [ADVAPI32.@]
 449  *
 450  * PARAMS
 451  *   pSid          []
 452  *   nSubAuthority []
 453  */
 454 PDWORD WINAPI
 455 GetSidSubAuthority( PSID pSid, DWORD nSubAuthority )
 456 {
 457         return RtlSubAuthoritySid(pSid, nSubAuthority);
 458 }
 459
 460 /******************************************************************************
 461  * GetSidSubAuthorityCount [ADVAPI32.@]
 462  *
 463  * PARAMS
 464  *   pSid []
 465  */
 466 PUCHAR WINAPI
 467 GetSidSubAuthorityCount (PSID pSid)
 468 {
 469         return RtlSubAuthorityCountSid(pSid);
 470 }
 471
 472 /******************************************************************************
 473  * GetLengthSid [ADVAPI32.@]
 474  *
 475  * PARAMS
 476  *   pSid []
 477  */
 478 DWORD WINAPI
 479 GetLengthSid (PSID pSid)
 480 {
 481         return RtlLengthSid(pSid);
 482 }
 483
 484 /*      ##############################################
 485         ######  SECURITY DESCRIPTOR FUNCTIONS   ######
 486         ##############################################
 487 */
 488
 489 /******************************************************************************
 490  * InitializeSecurityDescriptor [ADVAPI32.@]
 491  *
 492  * PARAMS
 493  *   pDescr   []
 494  *   revision []
 495  */
 496 BOOL WINAPI
 497 InitializeSecurityDescriptor( SECURITY_DESCRIPTOR *pDescr, DWORD revision )
 498 {
 499         CallWin32ToNt (RtlCreateSecurityDescriptor(pDescr, revision ));
 500 }
 501
 502 /******************************************************************************
 503  * GetSecurityDescriptorLength [ADVAPI32.@]
 504  */
 505 DWORD WINAPI GetSecurityDescriptorLength( SECURITY_DESCRIPTOR *pDescr)
 506 {
 507         return (RtlLengthSecurityDescriptor(pDescr));
 508 }
 509
 510 /******************************************************************************
 511  * GetSecurityDescriptorOwner [ADVAPI32.@]
 512  *
 513  * PARAMS
 514  *   pOwner            []
 515  *   lpbOwnerDefaulted []
 516  */
 517 BOOL WINAPI
 518 GetSecurityDescriptorOwner( SECURITY_DESCRIPTOR *pDescr, PSID *pOwner,
 519                             LPBOOL lpbOwnerDefaulted )
 520 {
 521         CallWin32ToNt (RtlGetOwnerSecurityDescriptor( pDescr, pOwner, (PBOOLEAN)lpbOwnerDefaulted ));
 522 }
 523
 524 /******************************************************************************
 525  * SetSecurityDescriptorOwner [ADVAPI32.@]
 526  *
 527  * PARAMS
 528  */
 529 BOOL WINAPI SetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor,
 530                                    PSID pOwner, BOOL bOwnerDefaulted)
 531 {
 532         CallWin32ToNt (RtlSetOwnerSecurityDescriptor(pSecurityDescriptor, pOwner, bOwnerDefaulted));
 533 }
 534 /******************************************************************************
 535  * GetSecurityDescriptorGroup                   [ADVAPI32.@]
 536  */
 537 BOOL WINAPI GetSecurityDescriptorGroup(
 538         PSECURITY_DESCRIPTOR SecurityDescriptor,
 539         PSID *Group,
 540         LPBOOL GroupDefaulted)
 541 {
 542         CallWin32ToNt (RtlGetGroupSecurityDescriptor(SecurityDescriptor, Group, (PBOOLEAN)GroupDefaulted));
 543 }
 544 /******************************************************************************
 545  * SetSecurityDescriptorGroup [ADVAPI32.@]
 546  */
 547 BOOL WINAPI SetSecurityDescriptorGroup ( PSECURITY_DESCRIPTOR SecurityDescriptor,
 548                                            PSID Group, BOOL GroupDefaulted)
 549 {
 550         CallWin32ToNt (RtlSetGroupSecurityDescriptor( SecurityDescriptor, Group, GroupDefaulted));
 551 }
 552
 553 /******************************************************************************
 554  * IsValidSecurityDescriptor [ADVAPI32.@]
 555  *
 556  * PARAMS
 557  *   lpsecdesc []
 558  */
 559 BOOL WINAPI
 560 IsValidSecurityDescriptor( PSECURITY_DESCRIPTOR SecurityDescriptor )
 561 {
 562         CallWin32ToNt (RtlValidSecurityDescriptor(SecurityDescriptor));
 563 }
 564
 565 /******************************************************************************
 566  *  GetSecurityDescriptorDacl                   [ADVAPI32.@]
 567  */
 568 BOOL WINAPI GetSecurityDescriptorDacl(
 569         IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 570         OUT LPBOOL lpbDaclPresent,
 571         OUT PACL *pDacl,
 572         OUT LPBOOL lpbDaclDefaulted)
 573 {
 574         CallWin32ToNt (RtlGetDaclSecurityDescriptor(pSecurityDescriptor, (PBOOLEAN)lpbDaclPresent,
 575                                                pDacl, (PBOOLEAN)lpbDaclDefaulted));
 576 }
 577
 578 /******************************************************************************
 579  *  SetSecurityDescriptorDacl                   [ADVAPI32.@]
 580  */
 581 BOOL WINAPI
 582 SetSecurityDescriptorDacl (
 583         PSECURITY_DESCRIPTOR lpsd,
 584         BOOL daclpresent,
 585         PACL dacl,
 586         BOOL dacldefaulted )
 587 {
 588         CallWin32ToNt (RtlSetDaclSecurityDescriptor (lpsd, daclpresent, dacl, dacldefaulted ));
 589 }
 590 /******************************************************************************
 591  *  GetSecurityDescriptorSacl                   [ADVAPI32.@]
 592  */
 593 BOOL WINAPI GetSecurityDescriptorSacl(
 594         IN PSECURITY_DESCRIPTOR lpsd,
 595         OUT LPBOOL lpbSaclPresent,
 596         OUT PACL *pSacl,
 597         OUT LPBOOL lpbSaclDefaulted)
 598 {
 599         CallWin32ToNt (RtlGetSaclSecurityDescriptor(lpsd,
 600            (PBOOLEAN)lpbSaclPresent, pSacl, (PBOOLEAN)lpbSaclDefaulted));
 601 }
 602
 603 /**************************************************************************
 604  * SetSecurityDescriptorSacl                    [ADVAPI32.@]
 605  */
 606 BOOL WINAPI SetSecurityDescriptorSacl (
 607         PSECURITY_DESCRIPTOR lpsd,
 608         BOOL saclpresent,
 609         PACL lpsacl,
 610         BOOL sacldefaulted)
 611 {
 612         CallWin32ToNt (RtlSetSaclSecurityDescriptor(lpsd, saclpresent, lpsacl, sacldefaulted));
 613 }
 614 /******************************************************************************
 615  * MakeSelfRelativeSD [ADVAPI32.@]
 616  *
 617  * PARAMS
 618  *   lpabssecdesc  []
 619  *   lpselfsecdesc []
 620  *   lpbuflen      []
 621  */
 622 BOOL WINAPI
 623 MakeSelfRelativeSD(
 624         IN PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
 625         IN PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
 626         IN OUT LPDWORD lpdwBufferLength)
 627 {
 628         CallWin32ToNt (RtlMakeSelfRelativeSD(pAbsoluteSecurityDescriptor,pSelfRelativeSecurityDescriptor, lpdwBufferLength));
 629 }
 630
 631 /******************************************************************************
 632  * GetSecurityDescriptorControl                 [ADVAPI32.@]
 633  */
 634
 635 BOOL WINAPI GetSecurityDescriptorControl ( PSECURITY_DESCRIPTOR  pSecurityDescriptor,
 636                  PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision)
 637 {
 638         CallWin32ToNt (RtlGetControlSecurityDescriptor(pSecurityDescriptor,pControl,lpdwRevision));
 639 }
 640
 641 /*      ##############################
 642         ######  ACL FUNCTIONS   ######
 643         ##############################
 644 */
 645
 646 /*************************************************************************
 647  * InitializeAcl [ADVAPI32.@]
 648  */
 649 DWORD WINAPI InitializeAcl(PACL acl, DWORD size, DWORD rev)
 650 {
 651         CallWin32ToNt (RtlCreateAcl(acl, size, rev));
 652 }
 653
 654 /******************************************************************************
 655  *  AddAccessAllowedAce [ADVAPI32.@]
 656  */
 657 BOOL WINAPI AddAccessAllowedAce(
 658         IN OUT PACL pAcl,
 659         IN DWORD dwAceRevision,
 660         IN DWORD AccessMask,
 661         IN PSID pSid)
 662 {
 663         CallWin32ToNt(RtlAddAccessAllowedAce(pAcl, dwAceRevision, AccessMask, pSid));
 664 }
 665
 666 /******************************************************************************
 667  *  AddAccessDeniedAce [ADVAPI32.@]
 668  */
 669 BOOL WINAPI AddAccessDeniedAce(
 670         IN OUT PACL pAcl,
 671         IN DWORD dwAceRevision,
 672         IN DWORD AccessMask,
 673         IN PSID pSid)
 674 {
 675         CallWin32ToNt(RtlAddAccessDeniedAce(pAcl, dwAceRevision, AccessMask, pSid));
 676 }
 677
 678 /******************************************************************************
 679  *  AddAccessDeniedAce [ADVAPI32.@]
 680  */
 681 BOOL WINAPI AddAce(
 682         IN OUT PACL pAcl,
 683         IN DWORD dwAceRevision,
 684         IN DWORD dwStartingAceIndex,
 685         LPVOID pAceList,
 686         DWORD nAceListLength)
 687 {
 688         CallWin32ToNt(RtlAddAce(pAcl, dwAceRevision, dwStartingAceIndex, pAceList, nAceListLength));
 689 }
 690
 691 /******************************************************************************
 692  *  FindFirstFreeAce [ADVAPI32.@]
 693  */
 694 BOOL WINAPI FindFirstFreeAce(IN PACL pAcl, LPVOID * pAce)
 695 {
 696         return RtlFirstFreeAce(pAcl, (PACE_HEADER *)pAce);
 697 }
 698
 699 /******************************************************************************
 700  * GetAce [ADVAPI32.@]
 701  */
 702 BOOL WINAPI GetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce )
 703 {
 704     CallWin32ToNt(RtlGetAce(pAcl, dwAceIndex, pAce));
 705 }
 706
 707 /******************************************************************************
 708  *  IsValidAcl [ADVAPI32.@]
 709  */
 710 BOOL WINAPI IsValidAcl(IN PACL pAcl)
 711 {
 712         return RtlValidAcl(pAcl);
 713 }
 714
 715 /*      ##############################
 716         ######  MISC FUNCTIONS  ######
 717         ##############################
 718 */
 719
 720 /******************************************************************************
 721  * LookupPrivilegeValueW                        [ADVAPI32.@]
 722  *
 723  * See LookupPrivilegeValueA.
 724  */
 725 BOOL WINAPI
 726 LookupPrivilegeValueW( LPCWSTR lpSystemName, LPCWSTR lpName, PLUID lpLuid )
 727 {
 728     FIXME("(%s,%s,%p): stub\n",debugstr_w(lpSystemName),
 729         debugstr_w(lpName), lpLuid);
 730     lpLuid->LowPart = 0x12345678;
 731     lpLuid->HighPart = 0x87654321;
 732     return TRUE;
 733 }
 734
 735 /******************************************************************************
 736  * LookupPrivilegeValueA                        [ADVAPI32.@]
 737  *
 738  * Retrieves LUID used on a system to represent the privilege name.
 739  *
 740  * PARAMS
 741  *  lpSystemName [I] Name of the system
 742  *  lpName       [I] Name of the privilege
 743  *  pLuid        [O] Destination for the resulting LUD
 744  *
 745  * RETURNS
 746  *  Success: TRUE. pLuid contains the requested LUID.
 747  *  Failure: FALSE.
 748  */
 749 BOOL WINAPI
 750 LookupPrivilegeValueA( LPCSTR lpSystemName, LPCSTR lpName, PLUID lpLuid )
 751 {
 752     UNICODE_STRING lpSystemNameW;
 753     UNICODE_STRING lpNameW;
 754     BOOL ret;
 755
 756     RtlCreateUnicodeStringFromAsciiz(&lpSystemNameW, lpSystemName);
 757     RtlCreateUnicodeStringFromAsciiz(&lpNameW,lpName);
 758     ret = LookupPrivilegeValueW(lpSystemNameW.Buffer, lpNameW.Buffer, lpLuid);
 759     RtlFreeUnicodeString(&lpNameW);
 760     RtlFreeUnicodeString(&lpSystemNameW);
 761     return ret;
 762 }
 763
 764 /******************************************************************************
 765  * GetFileSecurityA [ADVAPI32.@]
 766  *
 767  * Obtains Specified information about the security of a file or directory.
 768  *
 769  * PARAMS
 770  *  lpFileName           [I] Name of the file to get info for
 771  *  RequestedInformation [I] SE_ flags from "winnt.h"
 772  *  pSecurityDescriptor  [O] Destination for security information
 773  *  nLength              [I] Length of pSecurityDescriptor
 774  *  lpnLengthNeeded      [O] Destination for length of returned security information
 775  *
 776  * RETURNS
 777  *  Success: TRUE. pSecurityDescriptor contains the requested information.
 778  *  Failure: FALSE. lpnLengthNeeded contains the required space to return the info.
 779  *
 780  * NOTES
 781  *  The information returned is constrained by the callers access rights and
 782  *  privileges.
 783  */
 784 BOOL WINAPI
 785 GetFileSecurityA( LPCSTR lpFileName,
 786                     SECURITY_INFORMATION RequestedInformation,
 787                     PSECURITY_DESCRIPTOR pSecurityDescriptor,
 788                     DWORD nLength, LPDWORD lpnLengthNeeded )
 789 {
 790   FIXME("(%s) : stub\n", debugstr_a(lpFileName));
 791   return TRUE;
 792 }
 793
 794 /******************************************************************************
 795  * GetFileSecurityW [ADVAPI32.@]
 796  *
 797  * See GetFileSecurityA.
 798  */
 799 BOOL WINAPI
 800 GetFileSecurityW( LPCWSTR lpFileName,
 801                     SECURITY_INFORMATION RequestedInformation,
 802                     PSECURITY_DESCRIPTOR pSecurityDescriptor,
 803                     DWORD nLength, LPDWORD lpnLengthNeeded )
 804 {
 805   FIXME("(%s) : stub\n", debugstr_w(lpFileName) );
 806   return TRUE;
 807 }
 808
 809
 810 /******************************************************************************
 811  * LookupAccountSidA [ADVAPI32.@]
 812  */
 813 BOOL WINAPI
 814 LookupAccountSidA(
 815         IN LPCSTR system,
 816         IN PSID sid,
 817         OUT LPSTR account,
 818         IN OUT LPDWORD accountSize,
 819         OUT LPSTR domain,
 820         IN OUT LPDWORD domainSize,
 821         OUT PSID_NAME_USE name_use )
 822 {
 823         static const char ac[] = "Administrator";
 824         static const char dm[] = "DOMAIN";
 825         FIXME("(%s,sid=%p,%p,%p(%lu),%p,%p(%lu),%p): semi-stub\n",
 826               debugstr_a(system),sid,
 827               account,accountSize,accountSize?*accountSize:0,
 828               domain,domainSize,domainSize?*domainSize:0,
 829               name_use);
 830
 831         if (accountSize) *accountSize = strlen(ac)+1;
 832         if (account && (*accountSize > strlen(ac)))
 833           strcpy(account, ac);
 834
 835         if (domainSize) *domainSize = strlen(dm)+1;
 836         if (domain && (*domainSize > strlen(dm)))
 837           strcpy(domain,dm);
 838
 839         if (name_use) *name_use = SidTypeUser;
 840         return TRUE;
 841 }
 842
 843 /******************************************************************************
 844  * LookupAccountSidW [ADVAPI32.@]
 845  *
 846  * PARAMS
 847  *   system      []
 848  *   sid         []
 849  *   account     []
 850  *   accountSize []
 851  *   domain      []
 852  *   domainSize  []
 853  *   name_use    []
 854  */
 855 BOOL WINAPI
 856 LookupAccountSidW(
 857         IN LPCWSTR system,
 858         IN PSID sid,
 859         OUT LPWSTR account,
 860         IN OUT LPDWORD accountSize,
 861         OUT LPWSTR domain,
 862         IN OUT LPDWORD domainSize,
 863         OUT PSID_NAME_USE name_use )
 864 {
 865     static const WCHAR ac[] = {'A','d','m','i','n','i','s','t','r','a','t','o','r',0};
 866     static const WCHAR dm[] = {'D','O','M','A','I','N',0};
 867         FIXME("(%s,sid=%p,%p,%p(%lu),%p,%p(%lu),%p): semi-stub\n",
 868               debugstr_w(system),sid,
 869               account,accountSize,accountSize?*accountSize:0,
 870               domain,domainSize,domainSize?*domainSize:0,
 871               name_use);
 872
 873         if (accountSize) *accountSize = strlenW(ac)+1;
 874         if (account && (*accountSize > strlenW(ac)))
 875             strcpyW(account, ac);
 876
 877         if (domainSize) *domainSize = strlenW(dm)+1;
 878         if (domain && (*domainSize > strlenW(dm)))
 879             strcpyW(domain,dm);
 880
 881         if (name_use) *name_use = SidTypeUser;
 882         return TRUE;
 883 }
 884
 885 /******************************************************************************
 886  * SetFileSecurityA [ADVAPI32.@]
 887  * Sets the security of a file or directory
 888  */
 889 BOOL WINAPI SetFileSecurityA( LPCSTR lpFileName,
 890                                 SECURITY_INFORMATION RequestedInformation,
 891                                 PSECURITY_DESCRIPTOR pSecurityDescriptor)
 892 {
 893   FIXME("(%s) : stub\n", debugstr_a(lpFileName));
 894   return TRUE;
 895 }
 896
 897 /******************************************************************************
 898  * SetFileSecurityW [ADVAPI32.@]
 899  * Sets the security of a file or directory
 900  *
 901  * PARAMS
 902  *   lpFileName           []
 903  *   RequestedInformation []
 904  *   pSecurityDescriptor  []
 905  */
 906 BOOL WINAPI
 907 SetFileSecurityW( LPCWSTR lpFileName,
 908                     SECURITY_INFORMATION RequestedInformation,
 909                     PSECURITY_DESCRIPTOR pSecurityDescriptor )
 910 {
 911   FIXME("(%s) : stub\n", debugstr_w(lpFileName) );
 912   return TRUE;
 913 }
 914
 915 /******************************************************************************
 916  * QueryWindows31FilesMigration [ADVAPI32.@]
 917  *
 918  * PARAMS
 919  *   x1 []
 920  */
 921 BOOL WINAPI
 922 QueryWindows31FilesMigration( DWORD x1 )
 923 {
 924         FIXME("(%ld):stub\n",x1);
 925         return TRUE;
 926 }
 927
 928 /******************************************************************************
 929  * SynchronizeWindows31FilesAndWindowsNTRegistry [ADVAPI32.@]
 930  *
 931  * PARAMS
 932  *   x1 []
 933  *   x2 []
 934  *   x3 []
 935  *   x4 []
 936  */
 937 BOOL WINAPI
 938 SynchronizeWindows31FilesAndWindowsNTRegistry( DWORD x1, DWORD x2, DWORD x3,
 939                                                DWORD x4 )
 940 {
 941         FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx):stub\n",x1,x2,x3,x4);
 942         return TRUE;
 943 }
 944
 945 /******************************************************************************
 946  * LsaOpenPolicy [ADVAPI32.@]
 947  *
 948  * PARAMS
 949  *   x1 []
 950  *   x2 []
 951  *   x3 []
 952  *   x4 []
 953  */
 954 NTSTATUS WINAPI
 955 LsaOpenPolicy(
 956         IN PLSA_UNICODE_STRING SystemName,
 957         IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
 958         IN ACCESS_MASK DesiredAccess,
 959         IN OUT PLSA_HANDLE PolicyHandle)
 960 {
 961         FIXME("(%s,%p,0x%08lx,%p):stub\n",
 962               SystemName?debugstr_w(SystemName->Buffer):"null",
 963               ObjectAttributes, DesiredAccess, PolicyHandle);
 964         ADVAPI_ForceLocalComputer(SystemName ? SystemName->Buffer : NULL,
 965                                   STATUS_ACCESS_VIOLATION);
 966         dumpLsaAttributes(ObjectAttributes);
 967         if(PolicyHandle) *PolicyHandle = (LSA_HANDLE)0xcafe;
 968         return STATUS_SUCCESS;
 969 }
 970
 971 /******************************************************************************
 972  * LsaQueryInformationPolicy [ADVAPI32.@]
 973  */
 974 NTSTATUS WINAPI
 975 LsaQueryInformationPolicy(
 976         IN LSA_HANDLE PolicyHandle,
 977         IN POLICY_INFORMATION_CLASS InformationClass,
 978         OUT PVOID *Buffer)
 979 {
 980         FIXME("(%p,0x%08x,%p):stub\n",
 981               PolicyHandle, InformationClass, Buffer);
 982
 983         if(!Buffer) return FALSE;
 984         switch (InformationClass)
 985         {
 986           case PolicyAuditEventsInformation: /* 2 */
 987             {
 988               PPOLICY_AUDIT_EVENTS_INFO p = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(POLICY_AUDIT_EVENTS_INFO));
 989               p->AuditingMode = FALSE; /* no auditing */
 990               *Buffer = p;
 991             }
 992             break;
 993           case PolicyPrimaryDomainInformation: /* 3 */
 994           case PolicyAccountDomainInformation: /* 5 */
 995             {
 996               struct di
 997               { POLICY_PRIMARY_DOMAIN_INFO ppdi;
 998                 SID sid;
 999               };
1000               SID_IDENTIFIER_AUTHORITY localSidAuthority = {SECURITY_NT_AUTHORITY};
1001
1002               struct di * xdi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(xdi));
1003               RtlCreateUnicodeStringFromAsciiz(&(xdi->ppdi.Name), "DOMAIN");
1004
1005               xdi->ppdi.Sid = &(xdi->sid);
1006               xdi->sid.Revision = SID_REVISION;
1007               xdi->sid.SubAuthorityCount = 1;
1008               xdi->sid.IdentifierAuthority = localSidAuthority;
1009               xdi->sid.SubAuthority[0] = SECURITY_LOCAL_SYSTEM_RID;
1010               *Buffer = xdi;
1011             }
1012             break;
1013           case  PolicyAuditLogInformation:
1014           case  PolicyPdAccountInformation:
1015           case  PolicyLsaServerRoleInformation:
1016           case  PolicyReplicaSourceInformation:
1017           case  PolicyDefaultQuotaInformation:
1018           case  PolicyModificationInformation:
1019           case  PolicyAuditFullSetInformation:
1020           case  PolicyAuditFullQueryInformation:
1021           case  PolicyDnsDomainInformation:
1022             {
1023               FIXME("category not implemented\n");
1024               return FALSE;
1025             }
1026         }
1027         return TRUE;
1028 }
1029
1030 /******************************************************************************
1031  * LsaLookupSids [ADVAPI32.@]
1032  */
1033 typedef struct
1034 {
1035         SID_NAME_USE Use;
1036         LSA_UNICODE_STRING Name;
1037         LONG DomainIndex;
1038 } LSA_TRANSLATED_NAME, *PLSA_TRANSLATED_NAME;
1039
1040 typedef struct
1041 {
1042         LSA_UNICODE_STRING Name;
1043         PSID Sid;
1044 } LSA_TRUST_INFORMATION, *PLSA_TRUST_INFORMATION;
1045
1046 typedef struct
1047 {
1048         ULONG Entries;
1049         PLSA_TRUST_INFORMATION Domains;
1050 } LSA_REFERENCED_DOMAIN_LIST, *PLSA_REFERENCED_DOMAIN_LIST;
1051
1052 NTSTATUS WINAPI
1053 LsaLookupSids(
1054         IN LSA_HANDLE PolicyHandle,
1055         IN ULONG Count,
1056         IN PSID *Sids,
1057         OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1058         OUT PLSA_TRANSLATED_NAME *Names )
1059 {
1060         FIXME("%p %lu %p %p %p\n",
1061           PolicyHandle, Count, Sids, ReferencedDomains, Names);
1062         return FALSE;
1063 }
1064
1065 /******************************************************************************
1066  * LsaFreeMemory [ADVAPI32.@]
1067  */
1068 NTSTATUS WINAPI
1069 LsaFreeMemory(IN PVOID Buffer)
1070 {
1071         TRACE("(%p)\n",Buffer);
1072         return HeapFree(GetProcessHeap(), 0, Buffer);
1073 }
1074 /******************************************************************************
1075  * LsaClose [ADVAPI32.@]
1076  */
1077 NTSTATUS WINAPI
1078 LsaClose(IN LSA_HANDLE ObjectHandle)
1079 {
1080         FIXME("(%p):stub\n",ObjectHandle);
1081         return 0xc0000000;
1082 }
1083
1084 /******************************************************************************
1085  * LsaNtStatusToWinError [ADVAPI32.@]
1086  *
1087  * PARAMS
1088  *   Status [I]
1089  */
1090 ULONG WINAPI
1091 LsaNtStatusToWinError(NTSTATUS Status)
1092 {
1093     return RtlNtStatusToDosError(Status);
1094 }
1095
1096 /******************************************************************************
1097  * NotifyBootConfigStatus [ADVAPI32.@]
1098  *
1099  * PARAMS
1100  *   x1 []
1101  */
1102 BOOL WINAPI
1103 NotifyBootConfigStatus( DWORD x1 )
1104 {
1105         FIXME("(0x%08lx):stub\n",x1);
1106         return 1;
1107 }
1108
1109 /******************************************************************************
1110  * RevertToSelf [ADVAPI32.@]
1111  *
1112  * PARAMS
1113  *   void []
1114  */
1115 BOOL WINAPI
1116 RevertToSelf( void )
1117 {
1118         FIXME("(), stub\n");
1119         return TRUE;
1120 }
1121
1122 /******************************************************************************
1123  * ImpersonateSelf [ADVAPI32.@]
1124  */
1125 BOOL WINAPI
1126 ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
1127 {
1128         return RtlImpersonateSelf(ImpersonationLevel);
1129 }
1130
1131 /******************************************************************************
1132  * ImpersonateLoggedOnUser [ADVAPI32.@]
1133  */
1134 BOOL WINAPI ImpersonateLoggedOnUser(HANDLE hToken)
1135 {
1136     FIXME("(%p):stub returning FALSE\n", hToken);
1137     return FALSE;
1138 }
1139
1140 /******************************************************************************
1141  * AccessCheck [ADVAPI32.@]
1142  *
1143  * FIXME check cast LPBOOL to PBOOLEAN
1144  */
1145 BOOL WINAPI
1146 AccessCheck(
1147         PSECURITY_DESCRIPTOR SecurityDescriptor,
1148         HANDLE ClientToken,
1149         DWORD DesiredAccess,
1150         PGENERIC_MAPPING GenericMapping,
1151         PPRIVILEGE_SET PrivilegeSet,
1152         LPDWORD PrivilegeSetLength,
1153         LPDWORD GrantedAccess,
1154         LPBOOL AccessStatus)
1155 {
1156         CallWin32ToNt (NtAccessCheck(SecurityDescriptor, ClientToken, DesiredAccess,
1157           GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, (PBOOLEAN)AccessStatus));
1158 }
1159
1160 /*************************************************************************
1161  * SetKernelObjectSecurity [ADVAPI32.@]
1162  */
1163 BOOL WINAPI SetKernelObjectSecurity (
1164         IN HANDLE Handle,
1165         IN SECURITY_INFORMATION SecurityInformation,
1166         IN PSECURITY_DESCRIPTOR SecurityDescriptor )
1167 {
1168         CallWin32ToNt (NtSetSecurityObject (Handle, SecurityInformation, SecurityDescriptor));
1169 }
1170
1171 /******************************************************************************
1172  * LookupAccountNameA [ADVAPI32.@]
1173  */
1174 BOOL WINAPI
1175 LookupAccountNameA(
1176         IN LPCSTR system,
1177         IN LPCSTR account,
1178         OUT PSID sid,
1179         OUT LPDWORD cbSid,
1180         LPSTR ReferencedDomainName,
1181         IN OUT LPDWORD cbReferencedDomainName,
1182         OUT PSID_NAME_USE name_use )
1183 {
1184     FIXME("(%s,%s,%p,%p,%p,%p,%p), stub.\n",system,account,sid,cbSid,ReferencedDomainName,cbReferencedDomainName,name_use);
1185     return FALSE;
1186 }
1187
1188 /******************************************************************************
1189  * PrivilegeCheck [ADVAPI32.@]
1190  */
1191 BOOL WINAPI PrivilegeCheck( HANDLE ClientToken, PPRIVILEGE_SET RequiredPrivileges, LPBOOL pfResult)
1192 {
1193         FIXME("stub %p %p %p\n", ClientToken, RequiredPrivileges, pfResult);
1194         if (pfResult)
1195                 *pfResult=TRUE;
1196         return TRUE;
1197 }
1198
1199 /******************************************************************************
1200  * AccessCheckAndAuditAlarmA [ADVAPI32.@]
1201  */
1202 BOOL WINAPI AccessCheckAndAuditAlarmA(LPCSTR Subsystem, LPVOID HandleId, LPSTR ObjectTypeName,
1203   LPSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess,
1204   PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess,
1205   LPBOOL AccessStatus, LPBOOL pfGenerateOnClose)
1206 {
1207         FIXME("stub (%s,%p,%s,%s,%p,%08lx,%p,%x,%p,%p,%p)\n", debugstr_a(Subsystem),
1208                 HandleId, debugstr_a(ObjectTypeName), debugstr_a(ObjectName),
1209                 SecurityDescriptor, DesiredAccess, GenericMapping,
1210                 ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose);
1211         return TRUE;
1212 }
1213
1214 /******************************************************************************
1215  * AccessCheckAndAuditAlarmW [ADVAPI32.@]
1216  */
1217 BOOL WINAPI AccessCheckAndAuditAlarmW(LPCWSTR Subsystem, LPVOID HandleId, LPWSTR ObjectTypeName,
1218   LPWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess,
1219   PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess,
1220   LPBOOL AccessStatus, LPBOOL pfGenerateOnClose)
1221 {
1222         FIXME("stub (%s,%p,%s,%s,%p,%08lx,%p,%x,%p,%p,%p)\n", debugstr_w(Subsystem),
1223                 HandleId, debugstr_w(ObjectTypeName), debugstr_w(ObjectName),
1224                 SecurityDescriptor, DesiredAccess, GenericMapping,
1225                 ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose);
1226         return TRUE;
1227 }
1228
1229
1230 /******************************************************************************
1231  * GetSecurityInfoExW [ADVAPI32.@]
1232  */
1233 DWORD WINAPI GetSecurityInfoExW(
1234         HANDLE hObject, SE_OBJECT_TYPE ObjectType,
1235         SECURITY_INFORMATION SecurityInfo, LPCWSTR lpProvider,
1236         LPCWSTR lpProperty, PACTRL_ACCESSW *ppAccessList,
1237         PACTRL_AUDITW *ppAuditList, LPWSTR *lppOwner, LPWSTR *lppGroup
1238 )
1239 {
1240   FIXME("stub!\n");
1241   return ERROR_BAD_PROVIDER;
1242 }