reactos/dll/win32/advapi32/sec/lsa.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS system libraries
   4  * FILE:            dll/win32/advapi32/sec/lsa.c
   5  * PURPOSE:         Local security authority functions
   6  * PROGRAMMER:      Emanuele Aliberti
   7  * UPDATE HISTORY:
   8  *      19990322 EA created
   9  *      19990515 EA stubs
  10  *      20030202 KJK compressed stubs
  11  *
  12  */
  13 #include <advapi32.h>
  14 #include "wine/debug.h"
  15 #include "wine/unicode.h"
  16
  17 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
  18
  19
  20 static BOOL LsapIsLocalComputer(PLSA_UNICODE_STRING ServerName)
  21 {
  22     DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
  23     BOOL Result;
  24     LPWSTR buf;
  25
  26     if (ServerName == NULL || ServerName->Length == 0 || ServerName->Buffer == NULL)
  27         return TRUE;
  28
  29     buf = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
  30     Result = GetComputerNameW(buf, &dwSize);
  31     if (Result && (ServerName->Buffer[0] == '\\') && (ServerName->Buffer[1] == '\\'))
  32         ServerName += 2;
  33     Result = Result && !lstrcmpW(ServerName->Buffer, buf);
  34     HeapFree(GetProcessHeap(), 0, buf);
  35
  36     return Result;
  37 }
  38
  39
  40 handle_t __RPC_USER
  41 PLSAPR_SERVER_NAME_bind(PLSAPR_SERVER_NAME pszSystemName)
  42 {
  43     handle_t hBinding = NULL;
  44     LPWSTR pszStringBinding;
  45     RPC_STATUS status;
  46
  47     TRACE("PLSAPR_SERVER_NAME_bind() called\n");
  48
  49     status = RpcStringBindingComposeW(NULL,
  50                                       L"ncacn_np",
  51                                       pszSystemName,
  52                                       L"\\pipe\\lsarpc",
  53                                       NULL,
  54                                       &pszStringBinding);
  55     if (status)
  56     {
  57         TRACE("RpcStringBindingCompose returned 0x%x\n", status);
  58         return NULL;
  59     }
  60
  61     /* Set the binding handle that will be used to bind to the server. */
  62     status = RpcBindingFromStringBindingW(pszStringBinding,
  63                                           &hBinding);
  64     if (status)
  65     {
  66         TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
  67     }
  68
  69     status = RpcStringFreeW(&pszStringBinding);
  70     if (status)
  71     {
  72         TRACE("RpcStringFree returned 0x%x\n", status);
  73     }
  74
  75     return hBinding;
  76 }
  77
  78
  79 void __RPC_USER
  80 PLSAPR_SERVER_NAME_unbind(PLSAPR_SERVER_NAME pszSystemName,
  81                           handle_t hBinding)
  82 {
  83     RPC_STATUS status;
  84
  85     TRACE("PLSAPR_SERVER_NAME_unbind() called\n");
  86
  87     status = RpcBindingFree(&hBinding);
  88     if (status)
  89     {
  90         TRACE("RpcBindingFree returned 0x%x\n", status);
  91     }
  92 }
  93
  94
  95 /*
  96  * @implemented
  97  */
  98 NTSTATUS
  99 WINAPI
 100 LsaClose(IN LSA_HANDLE ObjectHandle)
 101 {
 102     NTSTATUS Status;
 103
 104     TRACE("LsaClose(0x%p) called\n", ObjectHandle);
 105
 106     RpcTryExcept
 107     {
 108         Status = LsarClose((PLSAPR_HANDLE)&ObjectHandle);
 109     }
 110     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 111     {
 112         Status = I_RpcMapWin32Status(RpcExceptionCode());
 113     }
 114     RpcEndExcept;
 115
 116     return Status;
 117 }
 118
 119
 120 /*
 121  * @implemented
 122  */
 123 NTSTATUS
 124 WINAPI
 125 LsaDelete(IN LSA_HANDLE ObjectHandle)
 126 {
 127     NTSTATUS Status;
 128
 129     TRACE("LsaDelete(0x%p) called\n", ObjectHandle);
 130
 131     RpcTryExcept
 132     {
 133         Status = LsarDelete((LSAPR_HANDLE)ObjectHandle);
 134     }
 135     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 136     {
 137         Status = I_RpcMapWin32Status(RpcExceptionCode());
 138     }
 139     RpcEndExcept;
 140
 141     return Status;
 142 }
 143
 144
 145 /*
 146  * @implemented
 147  */
 148 NTSTATUS
 149 WINAPI
 150 LsaAddAccountRights(IN LSA_HANDLE PolicyHandle,
 151                     IN PSID AccountSid,
 152                     IN PLSA_UNICODE_STRING UserRights,
 153                     IN ULONG CountOfRights)
 154 {
 155     LSAPR_USER_RIGHT_SET UserRightSet;
 156     NTSTATUS Status;
 157
 158     TRACE("(%p,%p,%p,0x%08x) stub\n", PolicyHandle, AccountSid, UserRights, CountOfRights);
 159
 160     UserRightSet.Entries = CountOfRights;
 161     UserRightSet.UserRights = (PRPC_UNICODE_STRING)UserRights;
 162
 163     RpcTryExcept
 164     {
 165         Status = LsarAddAccountRights((LSAPR_HANDLE)PolicyHandle,
 166                                       (PRPC_SID)AccountSid,
 167                                       &UserRightSet);
 168
 169     }
 170     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 171     {
 172         Status = I_RpcMapWin32Status(RpcExceptionCode());
 173     }
 174     RpcEndExcept;
 175
 176     return Status;
 177 }
 178
 179
 180 /*
 181  * @implemented
 182  */
 183 NTSTATUS
 184 WINAPI
 185 LsaAddPrivilegesToAccount(IN LSA_HANDLE AccountHandle,
 186                           IN PPRIVILEGE_SET PrivilegeSet)
 187 {
 188     NTSTATUS Status;
 189
 190     TRACE("(%p,%p) stub\n", AccountHandle, PrivilegeSet);
 191
 192     RpcTryExcept
 193     {
 194         Status = LsarAddPrivilegesToAccount((LSAPR_HANDLE)AccountHandle,
 195                                             (PLSAPR_PRIVILEGE_SET)PrivilegeSet);
 196     }
 197     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 198     {
 199         Status = I_RpcMapWin32Status(RpcExceptionCode());
 200     }
 201     RpcEndExcept;
 202
 203     return Status;
 204 }
 205
 206
 207 /*
 208  * @implemented
 209  */
 210 NTSTATUS
 211 WINAPI
 212 LsaCreateAccount(IN LSA_HANDLE PolicyHandle,
 213                  IN PSID AccountSid,
 214                  IN ULONG Flags,
 215                  OUT PLSA_HANDLE AccountHandle)
 216 {
 217     NTSTATUS Status;
 218
 219     TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, AccountSid, Flags, AccountHandle);
 220
 221     RpcTryExcept
 222     {
 223         Status = LsarCreateAccount((LSAPR_HANDLE)PolicyHandle,
 224                                    AccountSid,
 225                                    Flags,
 226                                    AccountHandle);
 227     }
 228     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 229     {
 230         Status = I_RpcMapWin32Status(RpcExceptionCode());
 231     }
 232     RpcEndExcept;
 233
 234     return Status;
 235 }
 236
 237
 238 /*
 239  * @implemented
 240  */
 241 NTSTATUS
 242 WINAPI
 243 LsaCreateTrustedDomain(IN LSA_HANDLE PolicyHandle,
 244                        IN PLSA_TRUST_INFORMATION TrustedDomainInformation,
 245                        IN ACCESS_MASK DesiredAccess,
 246                        OUT PLSA_HANDLE TrustedDomainHandle)
 247 {
 248     NTSTATUS Status;
 249
 250     TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, TrustedDomainInformation,
 251           DesiredAccess, TrustedDomainHandle);
 252
 253     RpcTryExcept
 254     {
 255         Status = LsarCreateTrustedDomain((LSAPR_HANDLE)PolicyHandle,
 256                                          (PLSAPR_TRUST_INFORMATION)TrustedDomainInformation,
 257                                          DesiredAccess,
 258                                          (PLSAPR_HANDLE)TrustedDomainHandle);
 259     }
 260     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 261     {
 262         Status = I_RpcMapWin32Status(RpcExceptionCode());
 263     }
 264     RpcEndExcept;
 265
 266     return Status;
 267 }
 268
 269
 270 /*
 271  * @unimplemented
 272  */
 273 NTSTATUS
 274 WINAPI
 275 LsaCreateTrustedDomainEx(
 276     LSA_HANDLE PolicyHandle,
 277     PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
 278     PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation,
 279     ACCESS_MASK DesiredAccess,
 280     PLSA_HANDLE TrustedDomainHandle)
 281 {
 282     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, TrustedDomainInformation, AuthenticationInformation,
 283           DesiredAccess, TrustedDomainHandle);
 284     return STATUS_SUCCESS;
 285 }
 286
 287
 288 /*
 289  * @implemented
 290  */
 291 NTSTATUS
 292 WINAPI
 293 LsaDeleteTrustedDomain(IN LSA_HANDLE PolicyHandle,
 294                        IN PSID TrustedDomainSid)
 295 {
 296     NTSTATUS Status;
 297
 298     TRACE("(%p,%p)\n", PolicyHandle, TrustedDomainSid);
 299
 300     RpcTryExcept
 301     {
 302         Status = LsarDeleteTrustedDomain((LSAPR_HANDLE)PolicyHandle,
 303                                          TrustedDomainSid);
 304     }
 305     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 306     {
 307         Status = I_RpcMapWin32Status(RpcExceptionCode());
 308     }
 309     RpcEndExcept;
 310
 311     return Status;
 312 }
 313
 314
 315 /*
 316  * @implemented
 317  */
 318 NTSTATUS
 319 WINAPI
 320 LsaEnumerateAccountRights(IN LSA_HANDLE PolicyHandle,
 321                           IN PSID AccountSid,
 322                           OUT PLSA_UNICODE_STRING *UserRights,
 323                           OUT PULONG CountOfRights)
 324 {
 325     LSAPR_USER_RIGHT_SET UserRightsSet;
 326     NTSTATUS Status;
 327
 328     TRACE("(%p,%p,%p,%p) stub\n", PolicyHandle, AccountSid, UserRights, CountOfRights);
 329
 330     UserRightsSet.Entries = 0;
 331     UserRightsSet.UserRights = NULL;
 332
 333     RpcTryExcept
 334     {
 335         Status = LsarEnmuerateAccountRights((LSAPR_HANDLE)PolicyHandle,
 336                                             AccountSid,
 337                                             &UserRightsSet);
 338
 339         *CountOfRights = UserRightsSet.Entries;
 340         *UserRights = (PUNICODE_STRING)UserRightsSet.UserRights;
 341     }
 342     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 343     {
 344         Status = I_RpcMapWin32Status(RpcExceptionCode());
 345
 346         if (UserRightsSet.UserRights != NULL)
 347         {
 348             MIDL_user_free(UserRightsSet.UserRights);
 349         }
 350     }
 351     RpcEndExcept;
 352
 353     return Status;
 354 }
 355
 356
 357 /*
 358  * @unimplemented
 359  */
 360 NTSTATUS
 361 WINAPI
 362 LsaEnumerateAccountsWithUserRight(
 363     LSA_HANDLE PolicyHandle,
 364     OPTIONAL PLSA_UNICODE_STRING UserRights,
 365     PVOID *EnumerationBuffer,
 366     PULONG CountReturned)
 367 {
 368     FIXME("(%p,%p,%p,%p) stub\n", PolicyHandle, UserRights, EnumerationBuffer, CountReturned);
 369     return STATUS_NO_MORE_ENTRIES;
 370 }
 371
 372 /*
 373  * @unimplemented
 374  */
 375 NTSTATUS
 376 WINAPI
 377 LsaEnumerateTrustedDomains(
 378     LSA_HANDLE PolicyHandle,
 379     PLSA_ENUMERATION_HANDLE EnumerationContext,
 380     PVOID *Buffer,
 381     ULONG PreferedMaximumLength,
 382     PULONG CountReturned)
 383 {
 384     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext,
 385         Buffer, PreferedMaximumLength, CountReturned);
 386
 387     if (CountReturned) *CountReturned = 0;
 388     return STATUS_SUCCESS;
 389 }
 390
 391 /*
 392  * @unimplemented
 393  */
 394 NTSTATUS
 395 WINAPI
 396 LsaEnumerateTrustedDomainsEx(
 397     LSA_HANDLE PolicyHandle,
 398     PLSA_ENUMERATION_HANDLE EnumerationContext,
 399     PVOID *Buffer,
 400     ULONG PreferedMaximumLength,
 401     PULONG CountReturned)
 402 {
 403     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext, Buffer,
 404         PreferedMaximumLength, CountReturned);
 405     if (CountReturned) *CountReturned = 0;
 406     return STATUS_SUCCESS;
 407 }
 408
 409
 410 /*
 411  * @implemented
 412  */
 413 NTSTATUS
 414 WINAPI
 415 LsaFreeMemory(IN PVOID Buffer)
 416 {
 417     TRACE("(%p)\n", Buffer);
 418     return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
 419 }
 420
 421
 422 /*
 423  * @implemented
 424  */
 425 NTSTATUS
 426 WINAPI
 427 LsaLookupNames(IN LSA_HANDLE PolicyHandle,
 428                IN ULONG Count,
 429                IN PLSA_UNICODE_STRING Names,
 430                OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 431                OUT PLSA_TRANSLATED_SID *Sids)
 432 {
 433     LSAPR_TRANSLATED_SIDS TranslatedSids = {0, NULL};
 434     ULONG MappedCount = 0;
 435     NTSTATUS Status;
 436
 437     TRACE("(%p,0x%08x,%p,%p,%p)\n", PolicyHandle, Count, Names,
 438           ReferencedDomains, Sids);
 439
 440     if (ReferencedDomains == NULL || Sids == NULL)
 441         return STATUS_INVALID_PARAMETER;
 442
 443     RpcTryExcept
 444     {
 445         *ReferencedDomains = NULL;
 446         *Sids = NULL;
 447
 448         TranslatedSids.Entries = Count;
 449
 450         Status = LsarLookupNames((LSAPR_HANDLE)PolicyHandle,
 451                                  Count,
 452                                  (PRPC_UNICODE_STRING)Names,
 453                                  (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
 454                                  &TranslatedSids,
 455                                  LsapLookupWksta,
 456                                  &MappedCount);
 457
 458         *Sids = (PLSA_TRANSLATED_SID)TranslatedSids.Sids;
 459     }
 460     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 461     {
 462         if (TranslatedSids.Sids != NULL)
 463             MIDL_user_free(TranslatedSids.Sids);
 464
 465         Status = I_RpcMapWin32Status(RpcExceptionCode());
 466     }
 467     RpcEndExcept;
 468
 469     return Status;
 470 }
 471
 472
 473 /*
 474  * @implemented
 475  */
 476 NTSTATUS
 477 WINAPI
 478 LsaLookupNames2(IN LSA_HANDLE PolicyHandle,
 479                 IN ULONG Flags,
 480                 IN ULONG Count,
 481                 IN PLSA_UNICODE_STRING Names,
 482                 OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 483                 OUT PLSA_TRANSLATED_SID2 *Sids)
 484 {
 485     LSAPR_TRANSLATED_SIDS_EX2 TranslatedSids = {0, NULL};
 486     ULONG MappedCount = 0;
 487     NTSTATUS Status;
 488
 489     TRACE("(%p,0x%08x,0x%08x,%p,%p,%p) stub\n", PolicyHandle, Flags,
 490           Count, Names, ReferencedDomains, Sids);
 491
 492     if (ReferencedDomains == NULL || Sids == NULL)
 493         return STATUS_INVALID_PARAMETER;
 494
 495     RpcTryExcept
 496     {
 497         *ReferencedDomains = NULL;
 498         *Sids = NULL;
 499
 500         TranslatedSids.Entries = Count;
 501
 502         Status = LsarLookupNames3((LSAPR_HANDLE)PolicyHandle,
 503                                   Count,
 504                                   (PRPC_UNICODE_STRING)Names,
 505                                   (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
 506                                   &TranslatedSids,
 507                                   LsapLookupWksta,
 508                                   &MappedCount,
 509                                   Flags,
 510                                   2);
 511
 512         *Sids = (PLSA_TRANSLATED_SID2)TranslatedSids.Sids;
 513     }
 514     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 515     {
 516         if (TranslatedSids.Sids != NULL)
 517             MIDL_user_free(TranslatedSids.Sids);
 518
 519         Status = I_RpcMapWin32Status(RpcExceptionCode());
 520     }
 521     RpcEndExcept;
 522
 523     return Status;
 524 }
 525
 526
 527 /*
 528  * @implemented
 529  */
 530 NTSTATUS
 531 WINAPI
 532 LsaLookupPrivilegeName(IN LSA_HANDLE PolicyHandle,
 533                        IN PLUID Value,
 534                        OUT PUNICODE_STRING *Name)
 535 {
 536     PRPC_UNICODE_STRING NameBuffer = NULL;
 537     NTSTATUS Status;
 538
 539     TRACE("(%p,%p,%p)\n", PolicyHandle, Value, Name);
 540
 541     RpcTryExcept
 542     {
 543         Status = LsarLookupPrivilegeName(PolicyHandle,
 544                                          Value,
 545                                          &NameBuffer);
 546
 547         *Name = (PUNICODE_STRING)NameBuffer;
 548     }
 549     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 550     {
 551         if (NameBuffer != NULL)
 552             MIDL_user_free(NameBuffer);
 553
 554         Status = I_RpcMapWin32Status(RpcExceptionCode());
 555     }
 556     RpcEndExcept;
 557
 558     return Status;
 559 }
 560
 561
 562 /*
 563  * @implemented
 564  */
 565 NTSTATUS
 566 WINAPI
 567 LsaLookupPrivilegeValue(IN LSA_HANDLE PolicyHandle,
 568                         IN PLSA_UNICODE_STRING Name,
 569                         OUT PLUID Value)
 570 {
 571     LUID Luid;
 572     NTSTATUS Status;
 573
 574     TRACE("(%p,%p,%p)\n", PolicyHandle, Name, Value);
 575
 576     RpcTryExcept
 577     {
 578         Status = LsarLookupPrivilegeValue(PolicyHandle,
 579                                           (PRPC_UNICODE_STRING)Name,
 580                                           &Luid);
 581         if (Status == STATUS_SUCCESS)
 582             *Value = Luid;
 583     }
 584     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 585     {
 586         Status = I_RpcMapWin32Status(RpcExceptionCode());
 587     }
 588     RpcEndExcept;
 589
 590     return Status;
 591 }
 592
 593
 594 /*
 595  * @implemented
 596  */
 597 NTSTATUS
 598 WINAPI
 599 LsaLookupSids(IN LSA_HANDLE PolicyHandle,
 600               IN ULONG Count,
 601               IN PSID *Sids,
 602               OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 603               OUT PLSA_TRANSLATED_NAME *Names)
 604 {
 605     LSAPR_SID_ENUM_BUFFER SidEnumBuffer;
 606     LSAPR_TRANSLATED_NAMES TranslatedNames;
 607     ULONG MappedCount = 0;
 608     NTSTATUS  Status;
 609
 610     TRACE("(%p,%u,%p,%p,%p)\n", PolicyHandle, Count, Sids,
 611           ReferencedDomains, Names);
 612
 613     if (Count == 0)
 614         return STATUS_INVALID_PARAMETER;
 615
 616     SidEnumBuffer.Entries = Count;
 617     SidEnumBuffer.SidInfo = (PLSAPR_SID_INFORMATION)Sids;
 618
 619     RpcTryExcept
 620     {
 621         *ReferencedDomains = NULL;
 622         *Names = NULL;
 623
 624         TranslatedNames.Entries = 0;
 625         TranslatedNames.Names = NULL;
 626
 627         Status = LsarLookupSids((LSAPR_HANDLE)PolicyHandle,
 628                                 &SidEnumBuffer,
 629                                 (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
 630                                 &TranslatedNames,
 631                                 LsapLookupWksta,
 632                                 &MappedCount);
 633
 634         *Names = (PLSA_TRANSLATED_NAME)TranslatedNames.Names;
 635     }
 636     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 637     {
 638         if (TranslatedNames.Names != NULL)
 639         {
 640             MIDL_user_free(TranslatedNames.Names);
 641         }
 642
 643         Status = I_RpcMapWin32Status(RpcExceptionCode());
 644     }
 645     RpcEndExcept;
 646
 647     return Status;
 648 }
 649
 650
 651 /******************************************************************************
 652  * LsaNtStatusToWinError
 653  *
 654  * PARAMS
 655  *   Status [I]
 656  *
 657  * @implemented
 658  */
 659 ULONG
 660 WINAPI
 661 LsaNtStatusToWinError(IN NTSTATUS Status)
 662 {
 663     TRACE("(%lx)\n", Status);
 664     return RtlNtStatusToDosError(Status);
 665 }
 666
 667
 668 /*
 669  * @implemented
 670  */
 671 NTSTATUS
 672 WINAPI
 673 LsaOpenAccount(IN LSA_HANDLE PolicyHandle,
 674                IN PSID AccountSid,
 675                IN ULONG Flags,
 676                OUT PLSA_HANDLE AccountHandle)
 677 {
 678     NTSTATUS Status;
 679
 680     TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, AccountSid, Flags, AccountHandle);
 681
 682     RpcTryExcept
 683     {
 684         Status = LsarOpenAccount((LSAPR_HANDLE)PolicyHandle,
 685                                  AccountSid,
 686                                  Flags,
 687                                  AccountHandle);
 688     }
 689     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 690     {
 691         Status = I_RpcMapWin32Status(RpcExceptionCode());
 692     }
 693     RpcEndExcept;
 694
 695     return Status;
 696 }
 697
 698
 699 /******************************************************************************
 700  * LsaOpenPolicy
 701  *
 702  * PARAMS
 703  *   x1 []
 704  *   x2 []
 705  *   x3 []
 706  *   x4 []
 707  *
 708  * @implemented
 709  */
 710 NTSTATUS
 711 WINAPI
 712 LsaOpenPolicy(IN PLSA_UNICODE_STRING SystemName,
 713               IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
 714               IN ACCESS_MASK DesiredAccess,
 715               OUT PLSA_HANDLE PolicyHandle)
 716 {
 717     NTSTATUS Status;
 718
 719     TRACE("LsaOpenPolicy (%s,%p,0x%08x,%p)\n",
 720           SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
 721           ObjectAttributes, DesiredAccess, PolicyHandle);
 722
 723     /* FIXME: RPC should take care of this */
 724     if (!LsapIsLocalComputer(SystemName))
 725         return RPC_NT_SERVER_UNAVAILABLE;
 726
 727     RpcTryExcept
 728     {
 729         *PolicyHandle = NULL;
 730
 731         Status = LsarOpenPolicy(SystemName ? SystemName->Buffer : NULL,
 732                                 (PLSAPR_OBJECT_ATTRIBUTES)ObjectAttributes,
 733                                 DesiredAccess,
 734                                 PolicyHandle);
 735     }
 736     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 737     {
 738         Status = I_RpcMapWin32Status(RpcExceptionCode());
 739     }
 740     RpcEndExcept;
 741
 742     TRACE("LsaOpenPolicy() done (Status: 0x%08lx)\n", Status);
 743
 744     return Status;
 745 }
 746
 747
 748 /*
 749  * @implemented
 750  */
 751 NTSTATUS
 752 WINAPI
 753 LsaOpenTrustedDomainByName(IN LSA_HANDLE PolicyHandle,
 754                            IN PLSA_UNICODE_STRING TrustedDomainName,
 755                            IN ACCESS_MASK DesiredAccess,
 756                            OUT PLSA_HANDLE TrustedDomainHandle)
 757 {
 758     NTSTATUS Status;
 759
 760     TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, TrustedDomainName,
 761           DesiredAccess, TrustedDomainHandle);
 762
 763     RpcTryExcept
 764     {
 765         Status = LsarOpenTrustedDomainByName((LSAPR_HANDLE)PolicyHandle,
 766                                              (PRPC_UNICODE_STRING)TrustedDomainName,
 767                                              DesiredAccess,
 768                                              TrustedDomainHandle);
 769     }
 770     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 771     {
 772         Status = I_RpcMapWin32Status(RpcExceptionCode());
 773     }
 774     RpcEndExcept;
 775
 776     return Status;
 777 }
 778
 779
 780 /*
 781  * @unimplemented
 782  */
 783 NTSTATUS
 784 WINAPI
 785 LsaQueryDomainInformationPolicy(
 786     LSA_HANDLE PolicyHandle,
 787     POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
 788     PVOID *Buffer)
 789 {
 790     FIXME("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 791     return STATUS_NOT_IMPLEMENTED;
 792 }
 793
 794
 795 /*
 796  * @unimplemented
 797  */
 798 NTSTATUS
 799 WINAPI
 800 LsaQueryForestTrustInformation(
 801     LSA_HANDLE PolicyHandle,
 802     PLSA_UNICODE_STRING TrustedDomainName,
 803     PLSA_FOREST_TRUST_INFORMATION * ForestTrustInfo)
 804 {
 805     FIXME("(%p,%p,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo);
 806     return STATUS_NOT_IMPLEMENTED;
 807 }
 808
 809
 810 /*
 811  * @implemented
 812  */
 813 NTSTATUS
 814 WINAPI
 815 LsaQueryInformationPolicy(IN LSA_HANDLE PolicyHandle,
 816                           IN POLICY_INFORMATION_CLASS InformationClass,
 817                           OUT PVOID *Buffer)
 818 {
 819     PLSAPR_POLICY_INFORMATION PolicyInformation = NULL;
 820     NTSTATUS Status;
 821
 822     TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 823
 824     RpcTryExcept
 825     {
 826         Status = LsarQueryInformationPolicy((LSAPR_HANDLE)PolicyHandle,
 827                                             InformationClass,
 828                                             &PolicyInformation);
 829         *Buffer = PolicyInformation;
 830     }
 831     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 832     {
 833         if (PolicyInformation != NULL)
 834             MIDL_user_free(PolicyInformation);
 835
 836         Status = I_RpcMapWin32Status(RpcExceptionCode());
 837     }
 838     RpcEndExcept;
 839
 840     TRACE("Done (Status: 0x%08x)\n", Status);
 841
 842     return Status;
 843 }
 844
 845
 846 /*
 847  * @unimplemented
 848  */
 849 NTSTATUS
 850 WINAPI
 851 LsaQueryTrustedDomainInfo(
 852     LSA_HANDLE PolicyHandle,
 853     PSID TrustedDomainSid,
 854     TRUSTED_INFORMATION_CLASS InformationClass,
 855     PVOID *Buffer)
 856 {
 857     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
 858     return STATUS_OBJECT_NAME_NOT_FOUND;
 859 }
 860
 861
 862 /*
 863  * @implemented
 864  */
 865 NTSTATUS
 866 WINAPI
 867 LsaQueryTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle,
 868                                 IN PLSA_UNICODE_STRING TrustedDomainName,
 869                                 IN TRUSTED_INFORMATION_CLASS InformationClass,
 870                                 OUT PVOID *Buffer)
 871 {
 872     NTSTATUS Status;
 873
 874     TRACE("(%p,%p,%d,%p)\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
 875
 876     if (InformationClass == TrustedDomainAuthInformationInternal ||
 877         InformationClass == TrustedDomainFullInformationInternal)
 878         return STATUS_INVALID_INFO_CLASS;
 879
 880     RpcTryExcept
 881     {
 882         Status = LsarQueryTrustedDomainInfoByName((LSAPR_HANDLE)PolicyHandle,
 883                                                   (PRPC_UNICODE_STRING)TrustedDomainName,
 884                                                   InformationClass,
 885                                                   (unsigned long *)Buffer); // Shuld be: (PLSAPR_POLICY_INFORMATION *)Buffer
 886     }
 887     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 888     {
 889         Status = I_RpcMapWin32Status(RpcExceptionCode());
 890     }
 891     RpcEndExcept;
 892
 893     return Status;
 894 }
 895
 896
 897 /*
 898  * @implemented
 899  */
 900 NTSTATUS
 901 WINAPI
 902 LsaRemoveAccountRights(IN LSA_HANDLE PolicyHandle,
 903                        IN PSID AccountSid,
 904                        IN BOOLEAN AllRights,
 905                        IN PLSA_UNICODE_STRING UserRights,
 906                        IN ULONG CountOfRights)
 907 {
 908     LSAPR_USER_RIGHT_SET UserRightSet;
 909     NTSTATUS Status;
 910
 911     TRACE("(%p,%p,%d,%p,0x%08x) stub\n", PolicyHandle, AccountSid, AllRights, UserRights, CountOfRights);
 912
 913     UserRightSet.Entries = CountOfRights;
 914     UserRightSet.UserRights = (PRPC_UNICODE_STRING)UserRights;
 915
 916     RpcTryExcept
 917     {
 918         Status = LsarRemoveAccountRights((LSAPR_HANDLE)PolicyHandle,
 919                                          (PRPC_SID)AccountSid,
 920                                          AllRights,
 921                                          &UserRightSet);
 922     }
 923     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 924     {
 925         Status = I_RpcMapWin32Status(RpcExceptionCode());
 926     }
 927     RpcEndExcept;
 928
 929     return STATUS_SUCCESS;
 930 }
 931
 932
 933 /*
 934  * @unimplemented
 935  */
 936 NTSTATUS
 937 WINAPI
 938 LsaRetrievePrivateData(
 939     LSA_HANDLE PolicyHandle,
 940     PLSA_UNICODE_STRING KeyName,
 941     PLSA_UNICODE_STRING *PrivateData)
 942 {
 943     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 944     return STATUS_OBJECT_NAME_NOT_FOUND;
 945 }
 946
 947 /*
 948  * @unimplemented
 949  */
 950 NTSTATUS
 951 WINAPI
 952 LsaSetDomainInformationPolicy(
 953     LSA_HANDLE PolicyHandle,
 954     POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
 955     PVOID Buffer)
 956 {
 957     FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
 958     return STATUS_UNSUCCESSFUL;
 959 }
 960
 961
 962 /*
 963  * @implemented
 964  */
 965 NTSTATUS
 966 WINAPI
 967 LsaSetInformationPolicy(IN LSA_HANDLE PolicyHandle,
 968                         IN POLICY_INFORMATION_CLASS InformationClass,
 969                         IN PVOID Buffer)
 970 {
 971     NTSTATUS Status;
 972
 973     TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 974
 975     RpcTryExcept
 976     {
 977         Status = LsarSetInformationPolicy((LSAPR_HANDLE)PolicyHandle,
 978                                           InformationClass,
 979                                           (PLSAPR_POLICY_INFORMATION)Buffer);
 980     }
 981     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 982     {
 983         Status = I_RpcMapWin32Status(RpcExceptionCode());
 984     }
 985     RpcEndExcept;
 986
 987     return Status;
 988 }
 989
 990
 991 /*
 992  * @unimplemented
 993  */
 994 NTSTATUS WINAPI LsaSetSecret(
 995     IN LSA_HANDLE SecretHandle,
 996     IN PLSA_UNICODE_STRING EncryptedCurrentValue,
 997     IN PLSA_UNICODE_STRING EncryptedOldValue)
 998 {
 999     FIXME("(%p,%p,%p) stub\n", SecretHandle, EncryptedCurrentValue,
1000             EncryptedOldValue);
1001     return STATUS_SUCCESS;
1002 }
1003
1004 /*
1005  * @unimplemented
1006  */
1007 NTSTATUS
1008 WINAPI
1009 LsaSetForestTrustInformation(
1010     LSA_HANDLE PolicyHandle,
1011     PLSA_UNICODE_STRING TrustedDomainName,
1012     PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
1013     BOOL CheckOnly,
1014     PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
1015 {
1016     FIXME("(%p,%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo, CheckOnly, CollisionInfo);
1017     return STATUS_NOT_IMPLEMENTED;
1018 }
1019
1020 /*
1021  * @unimplemented
1022  */
1023 NTSTATUS
1024 WINAPI
1025 LsaSetTrustedDomainInfoByName(
1026     LSA_HANDLE PolicyHandle,
1027     PLSA_UNICODE_STRING TrustedDomainName,
1028     TRUSTED_INFORMATION_CLASS InformationClass,
1029     PVOID Buffer)
1030 {
1031     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
1032     return STATUS_SUCCESS;
1033 }
1034
1035 /*
1036  * @unimplemented
1037  */
1038 NTSTATUS WINAPI LsaRegisterPolicyChangeNotification(
1039     POLICY_NOTIFICATION_INFORMATION_CLASS class,
1040     HANDLE event)
1041 {
1042     FIXME("(%d,%p) stub\n", class, event);
1043     return STATUS_UNSUCCESSFUL;
1044 }
1045
1046 /*
1047  * @unimplemented
1048  */
1049 NTSTATUS
1050 WINAPI
1051 LsaSetTrustedDomainInformation(
1052     LSA_HANDLE PolicyHandle,
1053     PSID TrustedDomainSid,
1054     TRUSTED_INFORMATION_CLASS InformationClass,
1055     PVOID Buffer)
1056 {
1057     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
1058     return STATUS_SUCCESS;
1059 }
1060
1061 /*
1062  * @unimplemented
1063  */
1064 NTSTATUS
1065 WINAPI
1066 LsaStorePrivateData(
1067     LSA_HANDLE PolicyHandle,
1068     PLSA_UNICODE_STRING KeyName,
1069     PLSA_UNICODE_STRING PrivateData)
1070 {
1071     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
1072     return STATUS_OBJECT_NAME_NOT_FOUND;
1073 }
1074
1075 /*
1076  * @unimplemented
1077  */
1078 NTSTATUS WINAPI LsaUnregisterPolicyChangeNotification(
1079     POLICY_NOTIFICATION_INFORMATION_CLASS class,
1080     HANDLE event)
1081 {
1082     FIXME("(%d,%p) stub\n", class, event);
1083     return STATUS_SUCCESS;
1084 }
1085
1086 /*
1087  * @unimplemented
1088  */
1089 NTSTATUS
1090 WINAPI
1091 LsaGetUserName(
1092     PUNICODE_STRING *UserName,
1093     PUNICODE_STRING *DomainName)
1094 {
1095     FIXME("(%p,%p) stub\n", UserName, DomainName);
1096     return STATUS_NOT_IMPLEMENTED;
1097 }
1098
1099 /*
1100  * @unimplemented
1101  */
1102 NTSTATUS
1103 WINAPI
1104 LsaQueryInfoTrustedDomain (DWORD Unknonw0,
1105                            DWORD Unknonw1,
1106                            DWORD Unknonw2)
1107 {
1108     FIXME("(%d,%d,%d) stub\n", Unknonw0, Unknonw1, Unknonw2);
1109     return STATUS_NOT_IMPLEMENTED;
1110 }
1111
1112
1113 /* EOF */