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 "heap.h"
  27 #include "ntddk.h"
  28 #include "ntsecapi.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
  32
  33 #define CallWin32ToNt(func) \
  34         { NTSTATUS ret; \
  35           ret = (func); \
  36           if (ret !=STATUS_SUCCESS) \
  37           { SetLastError (RtlNtStatusToDosError(ret)); return FALSE; } \
  38           return TRUE; \
  39         }
  40
  41 static void dumpLsaAttributes( PLSA_OBJECT_ATTRIBUTES oa )
  42 {
  43         if (oa)
  44         {
  45           TRACE("\n\tlength=%lu, rootdir=0x%08x, objectname=%s\n\tattr=0x%08lx, sid=%p qos=%p\n",
  46                 oa->Length, oa->RootDirectory,
  47                 oa->ObjectName?debugstr_w(oa->ObjectName->Buffer):"null",
  48                 oa->Attributes, oa->SecurityDescriptor, oa->SecurityQualityOfService);
  49         }
  50 }
  51
  52 /*      ##############################
  53         ######  TOKEN FUNCTIONS ######
  54         ##############################
  55 */
  56
  57 /******************************************************************************
  58  * OpenProcessToken                     [ADVAPI32.@]
  59  * Opens the access token associated with a process
  60  *
  61  * PARAMS
  62  *   ProcessHandle [I] Handle to process
  63  *   DesiredAccess [I] Desired access to process
  64  *   TokenHandle   [O] Pointer to handle of open access token
  65  *
  66  * RETURNS STD
  67  */
  68 BOOL WINAPI
  69 OpenProcessToken( HANDLE ProcessHandle, DWORD DesiredAccess,
  70                   HANDLE *TokenHandle )
  71 {
  72         CallWin32ToNt(NtOpenProcessToken( ProcessHandle, DesiredAccess, TokenHandle ));
  73 }
  74
  75 /******************************************************************************
  76  * OpenThreadToken [ADVAPI32.@]
  77  *
  78  * PARAMS
  79  *   thread        []
  80  *   desiredaccess []
  81  *   openasself    []
  82  *   thandle       []
  83  */
  84 BOOL WINAPI
  85 OpenThreadToken( HANDLE ThreadHandle, DWORD DesiredAccess,
  86                  BOOL OpenAsSelf, HANDLE *TokenHandle)
  87 {
  88         CallWin32ToNt (NtOpenThreadToken(ThreadHandle, DesiredAccess, OpenAsSelf, TokenHandle));
  89 }
  90
  91 /******************************************************************************
  92  * AdjustTokenPrivileges [ADVAPI32.@]
  93  *
  94  * PARAMS
  95  *   TokenHandle          []
  96  *   DisableAllPrivileges []
  97  *   NewState             []
  98  *   BufferLength         []
  99  *   PreviousState        []
 100  *   ReturnLength         []
 101  */
 102 BOOL WINAPI
 103 AdjustTokenPrivileges( HANDLE TokenHandle, BOOL DisableAllPrivileges,
 104                        LPVOID NewState, DWORD BufferLength,
 105                        LPVOID PreviousState, LPDWORD ReturnLength )
 106 {
 107         CallWin32ToNt(NtAdjustPrivilegesToken(TokenHandle, DisableAllPrivileges, NewState, BufferLength, PreviousState, ReturnLength));
 108 }
 109
 110 /******************************************************************************
 111  * CheckTokenMembership [ADVAPI32.@]
 112  *
 113  * PARAMS
 114  *   TokenHandle [I]
 115  *   SidToCheck  [I]
 116  *   IsMember    [O]
 117  */
 118 BOOL WINAPI
 119 CheckTokenMembership( HANDLE TokenHandle, PSID SidToCheck,
 120                       PBOOL IsMember )
 121 {
 122   FIXME("(0x%08x %p %p) stub!\n", TokenHandle, SidToCheck, IsMember);
 123
 124   *IsMember = TRUE;
 125   return(TRUE);
 126 }
 127
 128 /******************************************************************************
 129  * GetTokenInformation [ADVAPI32.@]
 130  *
 131  * PARAMS
 132  *   token           [I]
 133  *   tokeninfoclass  [I]
 134  *   tokeninfo       [O]
 135  *   tokeninfolength [I]
 136  *   retlen          [O]
 137  *
 138  */
 139 BOOL WINAPI
 140 GetTokenInformation( HANDLE token, TOKEN_INFORMATION_CLASS tokeninfoclass,
 141                      LPVOID tokeninfo, DWORD tokeninfolength, LPDWORD retlen )
 142 {
 143     TRACE("(%x, %s, %p, %ld, %p): \n",
 144           token,
 145           (tokeninfoclass == TokenUser) ? "TokenUser" :
 146           (tokeninfoclass == TokenGroups) ? "TokenGroups" :
 147           (tokeninfoclass == TokenPrivileges) ? "TokenPrivileges" :
 148           (tokeninfoclass == TokenOwner) ? "TokenOwner" :
 149           (tokeninfoclass == TokenPrimaryGroup) ? "TokenPrimaryGroup" :
 150           (tokeninfoclass == TokenDefaultDacl) ? "TokenDefaultDacl" :
 151           (tokeninfoclass == TokenSource) ? "TokenSource" :
 152           (tokeninfoclass == TokenType) ? "TokenType" :
 153           (tokeninfoclass == TokenImpersonationLevel) ? "TokenImpersonationLevel" :
 154           (tokeninfoclass == TokenStatistics) ? "TokenStatistics" :
 155           (tokeninfoclass == TokenRestrictedSids) ? "TokenRestrictedSids" :
 156           (tokeninfoclass == TokenSessionId) ? "TokenSessionId" :
 157           (tokeninfoclass == TokenGroupsAndPrivileges) ? "TokenGroupsAndPrivileges" :
 158           (tokeninfoclass == TokenSessionReference) ? "TokenSessionReference" :
 159           (tokeninfoclass == TokenSandBoxInert) ? "TokenSandBoxInert" :
 160           "Unknown",
 161           tokeninfo, tokeninfolength, retlen);
 162     CallWin32ToNt (NtQueryInformationToken( token, tokeninfoclass, tokeninfo, tokeninfolength, retlen));
 163 }
 164
 165 /******************************************************************************
 166  * SetTokenInformation [ADVAPI32.@]
 167  *
 168  * PARAMS
 169  *   token           [I]
 170  *   tokeninfoclass  [I]
 171  *   tokeninfo       [I]
 172  *   tokeninfolength [I]
 173  *
 174  */
 175 BOOL WINAPI
 176 SetTokenInformation( HANDLE token, TOKEN_INFORMATION_CLASS tokeninfoclass,
 177                      LPVOID tokeninfo, DWORD tokeninfolength )
 178 {
 179     FIXME("(%x, %s, %p, %ld): stub\n",
 180           token,
 181           (tokeninfoclass == TokenUser) ? "TokenUser" :
 182           (tokeninfoclass == TokenGroups) ? "TokenGroups" :
 183           (tokeninfoclass == TokenPrivileges) ? "TokenPrivileges" :
 184           (tokeninfoclass == TokenOwner) ? "TokenOwner" :
 185           (tokeninfoclass == TokenPrimaryGroup) ? "TokenPrimaryGroup" :
 186           (tokeninfoclass == TokenDefaultDacl) ? "TokenDefaultDacl" :
 187           (tokeninfoclass == TokenSource) ? "TokenSource" :
 188           (tokeninfoclass == TokenType) ? "TokenType" :
 189           (tokeninfoclass == TokenImpersonationLevel) ? "TokenImpersonationLevel" :
 190           (tokeninfoclass == TokenStatistics) ? "TokenStatistics" :
 191           (tokeninfoclass == TokenRestrictedSids) ? "TokenRestrictedSids" :
 192           (tokeninfoclass == TokenSessionId) ? "TokenSessionId" :
 193           (tokeninfoclass == TokenGroupsAndPrivileges) ? "TokenGroupsAndPrivileges" :
 194           (tokeninfoclass == TokenSessionReference) ? "TokenSessionReference" :
 195           (tokeninfoclass == TokenSandBoxInert) ? "TokenSandBoxInert" :
 196           "Unknown",
 197           tokeninfo, tokeninfolength);
 198
 199     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 200
 201     return FALSE;
 202 }
 203
 204 /*************************************************************************
 205  * SetThreadToken [ADVAPI32.@]
 206  *
 207  * Assigns an "impersonation token" to a thread so it can assume the
 208  * security privledges of another thread or process.  Can also remove
 209  * a previously assigned token.  Only supported on NT - it's a stub
 210  * exactly like this one on Win9X.
 211  *
 212  */
 213
 214 BOOL WINAPI SetThreadToken(PHANDLE thread, HANDLE token)
 215 {
 216     FIXME("(%p, %x): stub (NT impl. only)\n", thread, token);
 217
 218     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 219
 220     return FALSE;
 221 }
 222
 223 /*      ##############################
 224         ######  SID FUNCTIONS   ######
 225         ##############################
 226 */
 227
 228 /******************************************************************************
 229  * AllocateAndInitializeSid [ADVAPI32.@]
 230  *
 231  * PARAMS
 232  *   pIdentifierAuthority []
 233  *   nSubAuthorityCount   []
 234  *   nSubAuthority0       []
 235  *   nSubAuthority1       []
 236  *   nSubAuthority2       []
 237  *   nSubAuthority3       []
 238  *   nSubAuthority4       []
 239  *   nSubAuthority5       []
 240  *   nSubAuthority6       []
 241  *   nSubAuthority7       []
 242  *   pSid                 []
 243  */
 244 BOOL WINAPI
 245 AllocateAndInitializeSid( PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
 246                           BYTE nSubAuthorityCount,
 247                           DWORD nSubAuthority0, DWORD nSubAuthority1,
 248                           DWORD nSubAuthority2, DWORD nSubAuthority3,
 249                           DWORD nSubAuthority4, DWORD nSubAuthority5,
 250                           DWORD nSubAuthority6, DWORD nSubAuthority7,
 251                           PSID *pSid )
 252 {
 253         CallWin32ToNt (RtlAllocateAndInitializeSid(
 254                 pIdentifierAuthority, nSubAuthorityCount,
 255                 nSubAuthority0, nSubAuthority1, nSubAuthority2, nSubAuthority3,
 256                 nSubAuthority4, nSubAuthority5, nSubAuthority6, nSubAuthority7,
 257                 pSid ));
 258 }
 259
 260 /******************************************************************************
 261  * FreeSid [ADVAPI32.@]
 262  *
 263  * PARAMS
 264  *   pSid []
 265  */
 266 PVOID WINAPI
 267 FreeSid( PSID pSid )
 268 {
 269         RtlFreeSid(pSid);
 270         return NULL; /* is documented like this */
 271 }
 272
 273 /******************************************************************************
 274  * CopySid [ADVAPI32.@]
 275  *
 276  * PARAMS
 277  *   nDestinationSidLength []
 278  *   pDestinationSid       []
 279  *   pSourceSid            []
 280  */
 281 BOOL WINAPI
 282 CopySid( DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid )
 283 {
 284         return RtlCopySid(nDestinationSidLength, pDestinationSid, pSourceSid);
 285 }
 286
 287 /******************************************************************************
 288  * IsValidSid [ADVAPI32.@]
 289  *
 290  * PARAMS
 291  *   pSid []
 292  */
 293 BOOL WINAPI
 294 IsValidSid( PSID pSid )
 295 {
 296         return RtlValidSid( pSid );
 297 }
 298
 299 /******************************************************************************
 300  * EqualSid [ADVAPI32.@]
 301  *
 302  * PARAMS
 303  *   pSid1 []
 304  *   pSid2 []
 305  */
 306 BOOL WINAPI
 307 EqualSid( PSID pSid1, PSID pSid2 )
 308 {
 309         return RtlEqualSid( pSid1, pSid2 );
 310 }
 311
 312 /******************************************************************************
 313  * EqualPrefixSid [ADVAPI32.@]
 314  */
 315 BOOL WINAPI EqualPrefixSid (PSID pSid1, PSID pSid2)
 316 {
 317         return RtlEqualPrefixSid(pSid1, pSid2);
 318 }
 319
 320 /******************************************************************************
 321  * GetSidLengthRequired [ADVAPI32.@]
 322  *
 323  * PARAMS
 324  *   nSubAuthorityCount []
 325  */
 326 DWORD WINAPI
 327 GetSidLengthRequired( BYTE nSubAuthorityCount )
 328 {
 329         return RtlLengthRequiredSid(nSubAuthorityCount);
 330 }
 331
 332 /******************************************************************************
 333  * InitializeSid [ADVAPI32.@]
 334  *
 335  * PARAMS
 336  *   pIdentifierAuthority []
 337  */
 338 BOOL WINAPI
 339 InitializeSid (
 340         PSID pSid,
 341         PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
 342         BYTE nSubAuthorityCount)
 343 {
 344         return RtlInitializeSid(pSid, pIdentifierAuthority, nSubAuthorityCount);
 345 }
 346
 347 /******************************************************************************
 348  * GetSidIdentifierAuthority [ADVAPI32.@]
 349  *
 350  * PARAMS
 351  *   pSid []
 352  */
 353 PSID_IDENTIFIER_AUTHORITY WINAPI
 354 GetSidIdentifierAuthority( PSID pSid )
 355 {
 356         return RtlIdentifierAuthoritySid(pSid);
 357 }
 358
 359 /******************************************************************************
 360  * GetSidSubAuthority [ADVAPI32.@]
 361  *
 362  * PARAMS
 363  *   pSid          []
 364  *   nSubAuthority []
 365  */
 366 PDWORD WINAPI
 367 GetSidSubAuthority( PSID pSid, DWORD nSubAuthority )
 368 {
 369         return RtlSubAuthoritySid(pSid, nSubAuthority);
 370 }
 371
 372 /******************************************************************************
 373  * GetSidSubAuthorityCount [ADVAPI32.@]
 374  *
 375  * PARAMS
 376  *   pSid []
 377  */
 378 PUCHAR WINAPI
 379 GetSidSubAuthorityCount (PSID pSid)
 380 {
 381         return RtlSubAuthorityCountSid(pSid);
 382 }
 383
 384 /******************************************************************************
 385  * GetLengthSid [ADVAPI32.@]
 386  *
 387  * PARAMS
 388  *   pSid []
 389  */
 390 DWORD WINAPI
 391 GetLengthSid (PSID pSid)
 392 {
 393         return RtlLengthSid(pSid);
 394 }
 395
 396 /*      ##############################################
 397         ######  SECURITY DESCRIPTOR FUNCTIONS   ######
 398         ##############################################
 399 */
 400
 401 /******************************************************************************
 402  * InitializeSecurityDescriptor [ADVAPI32.@]
 403  *
 404  * PARAMS
 405  *   pDescr   []
 406  *   revision []
 407  */
 408 BOOL WINAPI
 409 InitializeSecurityDescriptor( SECURITY_DESCRIPTOR *pDescr, DWORD revision )
 410 {
 411         CallWin32ToNt (RtlCreateSecurityDescriptor(pDescr, revision ));
 412 }
 413
 414 /******************************************************************************
 415  * GetSecurityDescriptorLength [ADVAPI32.@]
 416  */
 417 DWORD WINAPI GetSecurityDescriptorLength( SECURITY_DESCRIPTOR *pDescr)
 418 {
 419         return (RtlLengthSecurityDescriptor(pDescr));
 420 }
 421
 422 /******************************************************************************
 423  * GetSecurityDescriptorOwner [ADVAPI32.@]
 424  *
 425  * PARAMS
 426  *   pOwner            []
 427  *   lpbOwnerDefaulted []
 428  */
 429 BOOL WINAPI
 430 GetSecurityDescriptorOwner( SECURITY_DESCRIPTOR *pDescr, PSID *pOwner,
 431                             LPBOOL lpbOwnerDefaulted )
 432 {
 433         CallWin32ToNt (RtlGetOwnerSecurityDescriptor( pDescr, pOwner, (PBOOLEAN)lpbOwnerDefaulted ));
 434 }
 435
 436 /******************************************************************************
 437  * SetSecurityDescriptorOwner [ADVAPI32.@]
 438  *
 439  * PARAMS
 440  */
 441 BOOL WINAPI SetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor,
 442                                    PSID pOwner, BOOL bOwnerDefaulted)
 443 {
 444         CallWin32ToNt (RtlSetOwnerSecurityDescriptor(pSecurityDescriptor, pOwner, bOwnerDefaulted));
 445 }
 446 /******************************************************************************
 447  * GetSecurityDescriptorGroup                   [ADVAPI32.@]
 448  */
 449 BOOL WINAPI GetSecurityDescriptorGroup(
 450         PSECURITY_DESCRIPTOR SecurityDescriptor,
 451         PSID *Group,
 452         LPBOOL GroupDefaulted)
 453 {
 454         CallWin32ToNt (RtlGetGroupSecurityDescriptor(SecurityDescriptor, Group, (PBOOLEAN)GroupDefaulted));
 455 }
 456 /******************************************************************************
 457  * SetSecurityDescriptorGroup [ADVAPI32.@]
 458  */
 459 BOOL WINAPI SetSecurityDescriptorGroup ( PSECURITY_DESCRIPTOR SecurityDescriptor,
 460                                            PSID Group, BOOL GroupDefaulted)
 461 {
 462         CallWin32ToNt (RtlSetGroupSecurityDescriptor( SecurityDescriptor, Group, GroupDefaulted));
 463 }
 464
 465 /******************************************************************************
 466  * IsValidSecurityDescriptor [ADVAPI32.@]
 467  *
 468  * PARAMS
 469  *   lpsecdesc []
 470  */
 471 BOOL WINAPI
 472 IsValidSecurityDescriptor( PSECURITY_DESCRIPTOR SecurityDescriptor )
 473 {
 474         CallWin32ToNt (RtlValidSecurityDescriptor(SecurityDescriptor));
 475 }
 476
 477 /******************************************************************************
 478  *  GetSecurityDescriptorDacl                   [ADVAPI32.@]
 479  */
 480 BOOL WINAPI GetSecurityDescriptorDacl(
 481         IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 482         OUT LPBOOL lpbDaclPresent,
 483         OUT PACL *pDacl,
 484         OUT LPBOOL lpbDaclDefaulted)
 485 {
 486         CallWin32ToNt (RtlGetDaclSecurityDescriptor(pSecurityDescriptor, (PBOOLEAN)lpbDaclPresent,
 487                                                pDacl, (PBOOLEAN)lpbDaclDefaulted));
 488 }
 489
 490 /******************************************************************************
 491  *  SetSecurityDescriptorDacl                   [ADVAPI32.@]
 492  */
 493 BOOL WINAPI
 494 SetSecurityDescriptorDacl (
 495         PSECURITY_DESCRIPTOR lpsd,
 496         BOOL daclpresent,
 497         PACL dacl,
 498         BOOL dacldefaulted )
 499 {
 500         CallWin32ToNt (RtlSetDaclSecurityDescriptor (lpsd, daclpresent, dacl, dacldefaulted ));
 501 }
 502 /******************************************************************************
 503  *  GetSecurityDescriptorSacl                   [ADVAPI32.@]
 504  */
 505 BOOL WINAPI GetSecurityDescriptorSacl(
 506         IN PSECURITY_DESCRIPTOR lpsd,
 507         OUT LPBOOL lpbSaclPresent,
 508         OUT PACL *pSacl,
 509         OUT LPBOOL lpbSaclDefaulted)
 510 {
 511         CallWin32ToNt (RtlGetSaclSecurityDescriptor(lpsd,
 512            (PBOOLEAN)lpbSaclPresent, pSacl, (PBOOLEAN)lpbSaclDefaulted));
 513 }
 514
 515 /**************************************************************************
 516  * SetSecurityDescriptorSacl                    [ADVAPI32.@]
 517  */
 518 BOOL WINAPI SetSecurityDescriptorSacl (
 519         PSECURITY_DESCRIPTOR lpsd,
 520         BOOL saclpresent,
 521         PACL lpsacl,
 522         BOOL sacldefaulted)
 523 {
 524         CallWin32ToNt (RtlSetSaclSecurityDescriptor(lpsd, saclpresent, lpsacl, sacldefaulted));
 525 }
 526 /******************************************************************************
 527  * MakeSelfRelativeSD [ADVAPI32.@]
 528  *
 529  * PARAMS
 530  *   lpabssecdesc  []
 531  *   lpselfsecdesc []
 532  *   lpbuflen      []
 533  */
 534 BOOL WINAPI
 535 MakeSelfRelativeSD(
 536         IN PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
 537         IN PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
 538         IN OUT LPDWORD lpdwBufferLength)
 539 {
 540         CallWin32ToNt (RtlMakeSelfRelativeSD(pAbsoluteSecurityDescriptor,pSelfRelativeSecurityDescriptor, lpdwBufferLength));
 541 }
 542
 543 /******************************************************************************
 544  * GetSecurityDescriptorControl                 [ADVAPI32.@]
 545  */
 546
 547 BOOL WINAPI GetSecurityDescriptorControl ( PSECURITY_DESCRIPTOR  pSecurityDescriptor,
 548                  PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision)
 549 {
 550         CallWin32ToNt (RtlGetControlSecurityDescriptor(pSecurityDescriptor,pControl,lpdwRevision));
 551 }
 552
 553 /*      ##############################
 554         ######  ACL FUNCTIONS   ######
 555         ##############################
 556 */
 557
 558 /*************************************************************************
 559  * InitializeAcl [ADVAPI32.@]
 560  */
 561 DWORD WINAPI InitializeAcl(PACL acl, DWORD size, DWORD rev)
 562 {
 563         CallWin32ToNt (RtlCreateAcl(acl, size, rev));
 564 }
 565
 566 /*      ##############################
 567         ######  MISC FUNCTIONS  ######
 568         ##############################
 569 */
 570
 571 /******************************************************************************
 572  * LookupPrivilegeValueW                        [ADVAPI32.@]
 573  * Retrieves LUID used on a system to represent the privilege name.
 574  *
 575  * NOTES
 576  *   lpLuid should be PLUID
 577  *
 578  * PARAMS
 579  *   lpSystemName [I] Address of string specifying the system
 580  *   lpName       [I] Address of string specifying the privilege
 581  *   lpLuid       [I] Address of locally unique identifier
 582  *
 583  * RETURNS STD
 584  */
 585 BOOL WINAPI
 586 LookupPrivilegeValueW( LPCWSTR lpSystemName, LPCWSTR lpName, LPVOID lpLuid )
 587 {
 588     FIXME("(%s,%s,%p): stub\n",debugstr_w(lpSystemName),
 589         debugstr_w(lpName), lpLuid);
 590     return TRUE;
 591 }
 592
 593 /******************************************************************************
 594  * LookupPrivilegeValueA                        [ADVAPI32.@]
 595  */
 596 BOOL WINAPI
 597 LookupPrivilegeValueA( LPCSTR lpSystemName, LPCSTR lpName, LPVOID lpLuid )
 598 {
 599     LPWSTR lpSystemNameW = HEAP_strdupAtoW(GetProcessHeap(), 0, lpSystemName);
 600     LPWSTR lpNameW = HEAP_strdupAtoW(GetProcessHeap(), 0, lpName);
 601     BOOL ret;
 602
 603     ret = LookupPrivilegeValueW( lpSystemNameW, lpNameW, lpLuid);
 604     HeapFree(GetProcessHeap(), 0, lpNameW);
 605     HeapFree(GetProcessHeap(), 0, lpSystemNameW);
 606     return ret;
 607 }
 608
 609 /******************************************************************************
 610  * GetFileSecurityA [ADVAPI32.@]
 611  *
 612  * Obtains Specified information about the security of a file or directory
 613  * The information obtained is constrained by the callers access rights and
 614  * privileges
 615  */
 616 BOOL WINAPI
 617 GetFileSecurityA( LPCSTR lpFileName,
 618                     SECURITY_INFORMATION RequestedInformation,
 619                     PSECURITY_DESCRIPTOR pSecurityDescriptor,
 620                     DWORD nLength, LPDWORD lpnLengthNeeded )
 621 {
 622   FIXME("(%s) : stub\n", debugstr_a(lpFileName));
 623   return TRUE;
 624 }
 625
 626 /******************************************************************************
 627  * GetFileSecurityW [ADVAPI32.@]
 628  *
 629  * Obtains Specified information about the security of a file or directory
 630  * The information obtained is constrained by the callers access rights and
 631  * privileges
 632  *
 633  * PARAMS
 634  *   lpFileName           []
 635  *   RequestedInformation []
 636  *   pSecurityDescriptor  []
 637  *   nLength              []
 638  *   lpnLengthNeeded      []
 639  */
 640 BOOL WINAPI
 641 GetFileSecurityW( LPCWSTR lpFileName,
 642                     SECURITY_INFORMATION RequestedInformation,
 643                     PSECURITY_DESCRIPTOR pSecurityDescriptor,
 644                     DWORD nLength, LPDWORD lpnLengthNeeded )
 645 {
 646   FIXME("(%s) : stub\n", debugstr_w(lpFileName) );
 647   return TRUE;
 648 }
 649
 650
 651 /******************************************************************************
 652  * LookupAccountSidA [ADVAPI32.@]
 653  */
 654 BOOL WINAPI
 655 LookupAccountSidA(
 656         IN LPCSTR system,
 657         IN PSID sid,
 658         OUT LPSTR account,
 659         IN OUT LPDWORD accountSize,
 660         OUT LPSTR domain,
 661         IN OUT LPDWORD domainSize,
 662         OUT PSID_NAME_USE name_use )
 663 {
 664         static const char ac[] = "Administrator";
 665         static const char dm[] = "DOMAIN";
 666         FIXME("(%s,sid=%p,%p,%p(%lu),%p,%p(%lu),%p): semi-stub\n",
 667               debugstr_a(system),sid,
 668               account,accountSize,accountSize?*accountSize:0,
 669               domain,domainSize,domainSize?*domainSize:0,
 670               name_use);
 671
 672         if (accountSize) *accountSize = strlen(ac)+1;
 673         if (account && (*accountSize > strlen(ac)))
 674           strcpy(account, ac);
 675
 676         if (domainSize) *domainSize = strlen(dm)+1;
 677         if (domain && (*domainSize > strlen(dm)))
 678           strcpy(domain,dm);
 679
 680         if (name_use) *name_use = SidTypeUser;
 681         return TRUE;
 682 }
 683
 684 /******************************************************************************
 685  * LookupAccountSidW [ADVAPI32.@]
 686  *
 687  * PARAMS
 688  *   system      []
 689  *   sid         []
 690  *   account     []
 691  *   accountSize []
 692  *   domain      []
 693  *   domainSize  []
 694  *   name_use    []
 695  */
 696 BOOL WINAPI
 697 LookupAccountSidW(
 698         IN LPCWSTR system,
 699         IN PSID sid,
 700         OUT LPWSTR account,
 701         IN OUT LPDWORD accountSize,
 702         OUT LPWSTR domain,
 703         IN OUT LPDWORD domainSize,
 704         OUT PSID_NAME_USE name_use )
 705 {
 706     static const WCHAR ac[] = {'A','d','m','i','n','i','s','t','r','a','t','o','r',0};
 707     static const WCHAR dm[] = {'D','O','M','A','I','N',0};
 708         FIXME("(%s,sid=%p,%p,%p(%lu),%p,%p(%lu),%p): semi-stub\n",
 709               debugstr_w(system),sid,
 710               account,accountSize,accountSize?*accountSize:0,
 711               domain,domainSize,domainSize?*domainSize:0,
 712               name_use);
 713
 714         if (accountSize) *accountSize = strlenW(ac)+1;
 715         if (account && (*accountSize > strlenW(ac)))
 716             strcpyW(account, ac);
 717
 718         if (domainSize) *domainSize = strlenW(dm)+1;
 719         if (domain && (*domainSize > strlenW(dm)))
 720             strcpyW(domain,dm);
 721
 722         if (name_use) *name_use = SidTypeUser;
 723         return TRUE;
 724 }
 725
 726 /******************************************************************************
 727  * SetFileSecurityA [ADVAPI32.@]
 728  * Sets the security of a file or directory
 729  */
 730 BOOL WINAPI SetFileSecurityA( LPCSTR lpFileName,
 731                                 SECURITY_INFORMATION RequestedInformation,
 732                                 PSECURITY_DESCRIPTOR pSecurityDescriptor)
 733 {
 734   FIXME("(%s) : stub\n", debugstr_a(lpFileName));
 735   return TRUE;
 736 }
 737
 738 /******************************************************************************
 739  * SetFileSecurityW [ADVAPI32.@]
 740  * Sets the security of a file or directory
 741  *
 742  * PARAMS
 743  *   lpFileName           []
 744  *   RequestedInformation []
 745  *   pSecurityDescriptor  []
 746  */
 747 BOOL WINAPI
 748 SetFileSecurityW( LPCWSTR lpFileName,
 749                     SECURITY_INFORMATION RequestedInformation,
 750                     PSECURITY_DESCRIPTOR pSecurityDescriptor )
 751 {
 752   FIXME("(%s) : stub\n", debugstr_w(lpFileName) );
 753   return TRUE;
 754 }
 755
 756 /******************************************************************************
 757  * QueryWindows31FilesMigration [ADVAPI32.@]
 758  *
 759  * PARAMS
 760  *   x1 []
 761  */
 762 BOOL WINAPI
 763 QueryWindows31FilesMigration( DWORD x1 )
 764 {
 765         FIXME("(%ld):stub\n",x1);
 766         return TRUE;
 767 }
 768
 769 /******************************************************************************
 770  * SynchronizeWindows31FilesAndWindowsNTRegistry [ADVAPI32.@]
 771  *
 772  * PARAMS
 773  *   x1 []
 774  *   x2 []
 775  *   x3 []
 776  *   x4 []
 777  */
 778 BOOL WINAPI
 779 SynchronizeWindows31FilesAndWindowsNTRegistry( DWORD x1, DWORD x2, DWORD x3,
 780                                                DWORD x4 )
 781 {
 782         FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx):stub\n",x1,x2,x3,x4);
 783         return TRUE;
 784 }
 785
 786 /******************************************************************************
 787  * LsaOpenPolicy [ADVAPI32.@]
 788  *
 789  * PARAMS
 790  *   x1 []
 791  *   x2 []
 792  *   x3 []
 793  *   x4 []
 794  */
 795 NTSTATUS WINAPI
 796 LsaOpenPolicy(
 797         IN PLSA_UNICODE_STRING SystemName,
 798         IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
 799         IN ACCESS_MASK DesiredAccess,
 800         IN OUT PLSA_HANDLE PolicyHandle)
 801 {
 802         FIXME("(%s,%p,0x%08lx,%p):stub\n",
 803               SystemName?debugstr_w(SystemName->Buffer):"null",
 804               ObjectAttributes, DesiredAccess, PolicyHandle);
 805         dumpLsaAttributes(ObjectAttributes);
 806         if(PolicyHandle) *PolicyHandle = (LSA_HANDLE)0xcafe;
 807         return TRUE;
 808 }
 809
 810 /******************************************************************************
 811  * LsaQueryInformationPolicy [ADVAPI32.@]
 812  */
 813 NTSTATUS WINAPI
 814 LsaQueryInformationPolicy(
 815         IN LSA_HANDLE PolicyHandle,
 816         IN POLICY_INFORMATION_CLASS InformationClass,
 817         OUT PVOID *Buffer)
 818 {
 819         FIXME("(%p,0x%08x,%p):stub\n",
 820               PolicyHandle, InformationClass, Buffer);
 821
 822         if(!Buffer) return FALSE;
 823         switch (InformationClass)
 824         {
 825           case PolicyAuditEventsInformation: /* 2 */
 826             {
 827               PPOLICY_AUDIT_EVENTS_INFO p = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(POLICY_AUDIT_EVENTS_INFO));
 828               p->AuditingMode = FALSE; /* no auditing */
 829               *Buffer = p;
 830             }
 831             break;
 832           case PolicyPrimaryDomainInformation: /* 3 */
 833           case PolicyAccountDomainInformation: /* 5 */
 834             {
 835               struct di
 836               { POLICY_PRIMARY_DOMAIN_INFO ppdi;
 837                 SID sid;
 838               };
 839               SID_IDENTIFIER_AUTHORITY localSidAuthority = {SECURITY_NT_AUTHORITY};
 840
 841               struct di * xdi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(xdi));
 842               RtlInitUnicodeString(&(xdi->ppdi.Name), HEAP_strdupAtoW(GetProcessHeap(),0,"DOMAIN"));
 843               xdi->ppdi.Sid = &(xdi->sid);
 844               xdi->sid.Revision = SID_REVISION;
 845               xdi->sid.SubAuthorityCount = 1;
 846               xdi->sid.IdentifierAuthority = localSidAuthority;
 847               xdi->sid.SubAuthority[0] = SECURITY_LOCAL_SYSTEM_RID;
 848               *Buffer = xdi;
 849             }
 850             break;
 851           case  PolicyAuditLogInformation:
 852           case  PolicyPdAccountInformation:
 853           case  PolicyLsaServerRoleInformation:
 854           case  PolicyReplicaSourceInformation:
 855           case  PolicyDefaultQuotaInformation:
 856           case  PolicyModificationInformation:
 857           case  PolicyAuditFullSetInformation:
 858           case  PolicyAuditFullQueryInformation:
 859           case  PolicyDnsDomainInformation:
 860             {
 861               FIXME("category not implemented\n");
 862               return FALSE;
 863             }
 864         }
 865         return TRUE;
 866 }
 867
 868 /******************************************************************************
 869  * LsaLookupSids [ADVAPI32.@]
 870  */
 871 typedef struct
 872 {
 873         SID_NAME_USE Use;
 874         LSA_UNICODE_STRING Name;
 875         LONG DomainIndex;
 876 } LSA_TRANSLATED_NAME, *PLSA_TRANSLATED_NAME;
 877
 878 typedef struct
 879 {
 880         LSA_UNICODE_STRING Name;
 881         PSID Sid;
 882 } LSA_TRUST_INFORMATION, *PLSA_TRUST_INFORMATION;
 883
 884 typedef struct
 885 {
 886         ULONG Entries;
 887         PLSA_TRUST_INFORMATION Domains;
 888 } LSA_REFERENCED_DOMAIN_LIST, *PLSA_REFERENCED_DOMAIN_LIST;
 889
 890 NTSTATUS WINAPI
 891 LsaLookupSids(
 892         IN LSA_HANDLE PolicyHandle,
 893         IN ULONG Count,
 894         IN PSID *Sids,
 895         OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 896         OUT PLSA_TRANSLATED_NAME *Names )
 897 {
 898         FIXME("%p %lu %p %p %p\n",
 899           PolicyHandle, Count, Sids, ReferencedDomains, Names);
 900         return FALSE;
 901 }
 902
 903 /******************************************************************************
 904  * LsaFreeMemory [ADVAPI32.@]
 905  */
 906 NTSTATUS WINAPI
 907 LsaFreeMemory(IN PVOID Buffer)
 908 {
 909         TRACE("(%p)\n",Buffer);
 910         return HeapFree(GetProcessHeap(), 0, Buffer);
 911 }
 912 /******************************************************************************
 913  * LsaClose [ADVAPI32.@]
 914  */
 915 NTSTATUS WINAPI
 916 LsaClose(IN LSA_HANDLE ObjectHandle)
 917 {
 918         FIXME("(%p):stub\n",ObjectHandle);
 919         return 0xc0000000;
 920 }
 921
 922 /******************************************************************************
 923  * LsaNtStatusToWinError [ADVAPI32.@]
 924  *
 925  * PARAMS
 926  *   Status [I]
 927  */
 928 ULONG WINAPI
 929 LsaNtStatusToWinError(NTSTATUS Status)
 930 {
 931     return RtlNtStatusToDosError(Status);
 932 }
 933
 934 /******************************************************************************
 935  * NotifyBootConfigStatus [ADVAPI32.@]
 936  *
 937  * PARAMS
 938  *   x1 []
 939  */
 940 BOOL WINAPI
 941 NotifyBootConfigStatus( DWORD x1 )
 942 {
 943         FIXME("(0x%08lx):stub\n",x1);
 944         return 1;
 945 }
 946
 947 /******************************************************************************
 948  * RevertToSelf [ADVAPI32.@]
 949  *
 950  * PARAMS
 951  *   void []
 952  */
 953 BOOL WINAPI
 954 RevertToSelf( void )
 955 {
 956         FIXME("(), stub\n");
 957         return TRUE;
 958 }
 959
 960 /******************************************************************************
 961  * ImpersonateSelf [ADVAPI32.@]
 962  */
 963 BOOL WINAPI
 964 ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
 965 {
 966         return RtlImpersonateSelf(ImpersonationLevel);
 967 }
 968
 969 /******************************************************************************
 970  * ImpersonateLoggedOnUser [ADVAPI32.@]
 971  */
 972 BOOL WINAPI ImpersonateLoggedOnUser(HANDLE hToken)
 973 {
 974     FIXME("(%08x):stub returning FALSE\n", hToken);
 975     return FALSE;
 976 }
 977
 978 /******************************************************************************
 979  * AccessCheck [ADVAPI32.@]
 980  *
 981  * FIXME check cast LPBOOL to PBOOLEAN
 982  */
 983 BOOL WINAPI
 984 AccessCheck(
 985         PSECURITY_DESCRIPTOR SecurityDescriptor,
 986         HANDLE ClientToken,
 987         DWORD DesiredAccess,
 988         PGENERIC_MAPPING GenericMapping,
 989         PPRIVILEGE_SET PrivilegeSet,
 990         LPDWORD PrivilegeSetLength,
 991         LPDWORD GrantedAccess,
 992         LPBOOL AccessStatus)
 993 {
 994         CallWin32ToNt (NtAccessCheck(SecurityDescriptor, ClientToken, DesiredAccess,
 995           GenericMapping, PrivilegeSet, PrivilegeSetLength, GrantedAccess, (PBOOLEAN)AccessStatus));
 996 }
 997
 998 /*************************************************************************
 999  * SetKernelObjectSecurity [ADVAPI32.@]
1000  */
1001 BOOL WINAPI SetKernelObjectSecurity (
1002         IN HANDLE Handle,
1003         IN SECURITY_INFORMATION SecurityInformation,
1004         IN PSECURITY_DESCRIPTOR SecurityDescriptor )
1005 {
1006         CallWin32ToNt (NtSetSecurityObject (Handle, SecurityInformation, SecurityDescriptor));
1007 }
1008
1009 /******************************************************************************
1010  *  AddAccessAllowedAce [ADVAPI32.@]
1011  */
1012 BOOL WINAPI AddAccessAllowedAce(
1013         IN OUT PACL pAcl,
1014         IN DWORD dwAceRevision,
1015         IN DWORD AccessMask,
1016         IN PSID pSid)
1017 {
1018         return RtlAddAccessAllowedAce(pAcl, dwAceRevision, AccessMask, pSid);
1019 }
1020
1021 /******************************************************************************
1022  * LookupAccountNameA [ADVAPI32.@]
1023  */
1024 BOOL WINAPI
1025 LookupAccountNameA(
1026         IN LPCSTR system,
1027         IN LPCSTR account,
1028         OUT PSID sid,
1029         OUT LPDWORD cbSid,
1030         LPSTR ReferencedDomainName,
1031         IN OUT LPDWORD cbReferencedDomainName,
1032         OUT PSID_NAME_USE name_use )
1033 {
1034     FIXME("(%s,%s,%p,%p,%p,%p,%p), stub.\n",system,account,sid,cbSid,ReferencedDomainName,cbReferencedDomainName,name_use);
1035     return FALSE;
1036 }
1037
1038 /******************************************************************************
1039  * GetAce [ADVAPI32.@]
1040  */
1041 BOOL WINAPI GetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce )
1042 {
1043     CallWin32ToNt(RtlGetAce(pAcl, dwAceIndex, pAce));
1044 }
1045
1046 /******************************************************************************
1047  * PrivilegeCheck [ADVAPI32.@]
1048  */
1049 BOOL WINAPI PrivilegeCheck( HANDLE ClientToken, PPRIVILEGE_SET RequiredPrivileges, LPBOOL pfResult)
1050 {
1051         FIXME("stub %d %p %p\n", ClientToken, RequiredPrivileges, pfResult);
1052         if (pfResult)
1053                 *pfResult=TRUE;
1054         return TRUE;
1055 }