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  * @unimplemented
 147  */
 148 NTSTATUS
 149 WINAPI
 150 LsaAddAccountRights(
 151     LSA_HANDLE PolicyHandle,
 152     PSID AccountSid,
 153     PLSA_UNICODE_STRING UserRights,
 154     ULONG CountOfRights)
 155 {
 156     FIXME("(%p,%p,%p,0x%08x) stub\n", PolicyHandle, AccountSid, UserRights, CountOfRights);
 157     return STATUS_OBJECT_NAME_NOT_FOUND;
 158 }
 159
 160
 161 /*
 162  * @implemented
 163  */
 164 NTSTATUS
 165 WINAPI
 166 LsaAddPrivilegesToAccount(IN LSA_HANDLE AccountHandle,
 167                           IN PPRIVILEGE_SET PrivilegeSet)
 168 {
 169     NTSTATUS Status;
 170
 171     TRACE("(%p,%p) stub\n", AccountHandle, PrivilegeSet);
 172
 173     RpcTryExcept
 174     {
 175         Status = LsarAddPrivilegesToAccount((LSAPR_HANDLE)AccountHandle,
 176                                             (PLSAPR_PRIVILEGE_SET)PrivilegeSet);
 177     }
 178     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 179     {
 180         Status = I_RpcMapWin32Status(RpcExceptionCode());
 181     }
 182     RpcEndExcept;
 183
 184     return Status;
 185 }
 186
 187
 188 /*
 189  * @implemented
 190  */
 191 NTSTATUS
 192 WINAPI
 193 LsaCreateAccount(IN LSA_HANDLE PolicyHandle,
 194                  IN PSID AccountSid,
 195                  IN ULONG Flags,
 196                  OUT PLSA_HANDLE AccountHandle)
 197 {
 198     NTSTATUS Status;
 199
 200     TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, AccountSid, Flags, AccountHandle);
 201
 202     RpcTryExcept
 203     {
 204         Status = LsarCreateAccount((LSAPR_HANDLE)PolicyHandle,
 205                                    AccountSid,
 206                                    Flags,
 207                                    AccountHandle);
 208     }
 209     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 210     {
 211         Status = I_RpcMapWin32Status(RpcExceptionCode());
 212     }
 213     RpcEndExcept;
 214
 215     return Status;
 216 }
 217
 218
 219 /*
 220  * @implemented
 221  */
 222 NTSTATUS
 223 WINAPI
 224 LsaCreateTrustedDomain(IN LSA_HANDLE PolicyHandle,
 225                        IN PLSA_TRUST_INFORMATION TrustedDomainInformation,
 226                        IN ACCESS_MASK DesiredAccess,
 227                        OUT PLSA_HANDLE TrustedDomainHandle)
 228 {
 229     NTSTATUS Status;
 230
 231     TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, TrustedDomainInformation,
 232           DesiredAccess, TrustedDomainHandle);
 233
 234     RpcTryExcept
 235     {
 236         Status = LsarCreateTrustedDomain((LSAPR_HANDLE)PolicyHandle,
 237                                          (PLSAPR_TRUST_INFORMATION)TrustedDomainInformation,
 238                                          DesiredAccess,
 239                                          (PLSAPR_HANDLE)TrustedDomainHandle);
 240     }
 241     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 242     {
 243         Status = I_RpcMapWin32Status(RpcExceptionCode());
 244     }
 245     RpcEndExcept;
 246
 247     return Status;
 248 }
 249
 250
 251 /*
 252  * @unimplemented
 253  */
 254 NTSTATUS
 255 WINAPI
 256 LsaCreateTrustedDomainEx(
 257     LSA_HANDLE PolicyHandle,
 258     PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
 259     PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation,
 260     ACCESS_MASK DesiredAccess,
 261     PLSA_HANDLE TrustedDomainHandle)
 262 {
 263     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, TrustedDomainInformation, AuthenticationInformation,
 264           DesiredAccess, TrustedDomainHandle);
 265     return STATUS_SUCCESS;
 266 }
 267
 268 /*
 269  * @implemented
 270  */
 271 NTSTATUS
 272 WINAPI
 273 LsaDeleteTrustedDomain(IN LSA_HANDLE PolicyHandle,
 274                        IN PSID TrustedDomainSid)
 275 {
 276     NTSTATUS Status;
 277
 278     TRACE("(%p,%p)\n", PolicyHandle, TrustedDomainSid);
 279
 280     RpcTryExcept
 281     {
 282         Status = LsarDeleteTrustedDomain((LSAPR_HANDLE)PolicyHandle,
 283                                          TrustedDomainSid);
 284     }
 285     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 286     {
 287         Status = I_RpcMapWin32Status(RpcExceptionCode());
 288     }
 289     RpcEndExcept;
 290
 291     return Status;
 292 }
 293
 294 /*
 295  * @implemented
 296  */
 297 NTSTATUS
 298 WINAPI
 299 LsaEnumerateAccountRights(
 300     LSA_HANDLE PolicyHandle,
 301     PSID AccountSid,
 302     PLSA_UNICODE_STRING *UserRights,
 303     PULONG CountOfRights)
 304 {
 305     LSAPR_USER_RIGHT_SET UserRightsSet;
 306     NTSTATUS Status;
 307
 308     TRACE("(%p,%p,%p,%p) stub\n", PolicyHandle, AccountSid, UserRights, CountOfRights);
 309
 310     UserRightsSet.Entries = 0;
 311     UserRightsSet.UserRights = NULL;
 312
 313     RpcTryExcept
 314     {
 315         Status = LsarEnmuerateAccountRights((LSAPR_HANDLE)PolicyHandle,
 316                                             AccountSid,
 317                                             &UserRightsSet);
 318
 319         *CountOfRights = UserRightsSet.Entries;
 320         *UserRights = (PUNICODE_STRING)UserRightsSet.UserRights;
 321     }
 322     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 323     {
 324         Status = I_RpcMapWin32Status(RpcExceptionCode());
 325
 326         if (UserRightsSet.UserRights != NULL)
 327         {
 328             MIDL_user_free(UserRightsSet.UserRights);
 329         }
 330     }
 331     RpcEndExcept;
 332
 333     return Status;
 334 }
 335
 336 /*
 337  * @unimplemented
 338  */
 339 NTSTATUS
 340 WINAPI
 341 LsaEnumerateAccountsWithUserRight(
 342     LSA_HANDLE PolicyHandle,
 343     OPTIONAL PLSA_UNICODE_STRING UserRights,
 344     PVOID *EnumerationBuffer,
 345     PULONG CountReturned)
 346 {
 347     FIXME("(%p,%p,%p,%p) stub\n", PolicyHandle, UserRights, EnumerationBuffer, CountReturned);
 348     return STATUS_NO_MORE_ENTRIES;
 349 }
 350
 351 /*
 352  * @unimplemented
 353  */
 354 NTSTATUS
 355 WINAPI
 356 LsaEnumerateTrustedDomains(
 357     LSA_HANDLE PolicyHandle,
 358     PLSA_ENUMERATION_HANDLE EnumerationContext,
 359     PVOID *Buffer,
 360     ULONG PreferedMaximumLength,
 361     PULONG CountReturned)
 362 {
 363     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext,
 364         Buffer, PreferedMaximumLength, CountReturned);
 365
 366     if (CountReturned) *CountReturned = 0;
 367     return STATUS_SUCCESS;
 368 }
 369
 370 /*
 371  * @unimplemented
 372  */
 373 NTSTATUS
 374 WINAPI
 375 LsaEnumerateTrustedDomainsEx(
 376     LSA_HANDLE PolicyHandle,
 377     PLSA_ENUMERATION_HANDLE EnumerationContext,
 378     PVOID *Buffer,
 379     ULONG PreferedMaximumLength,
 380     PULONG CountReturned)
 381 {
 382     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext, Buffer,
 383         PreferedMaximumLength, CountReturned);
 384     if (CountReturned) *CountReturned = 0;
 385     return STATUS_SUCCESS;
 386 }
 387
 388 /*
 389  * @implemented
 390  */
 391 NTSTATUS
 392 WINAPI
 393 LsaFreeMemory(PVOID Buffer)
 394 {
 395     TRACE("(%p)\n", Buffer);
 396     return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
 397 }
 398
 399 /*
 400  * @implemented
 401  */
 402 NTSTATUS
 403 WINAPI
 404 LsaLookupNames(IN LSA_HANDLE PolicyHandle,
 405                IN ULONG Count,
 406                IN PLSA_UNICODE_STRING Names,
 407                OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 408                OUT PLSA_TRANSLATED_SID *Sids)
 409 {
 410     LSAPR_TRANSLATED_SIDS TranslatedSids;
 411     ULONG MappedCount = 0;
 412     NTSTATUS Status;
 413
 414     TRACE("(%p,0x%08x,%p,%p,%p)\n", PolicyHandle, Count, Names,
 415           ReferencedDomains, Sids);
 416
 417     RpcTryExcept
 418     {
 419         *ReferencedDomains = NULL;
 420         *Sids = NULL;
 421
 422         TranslatedSids.Entries = Count;
 423         TranslatedSids.Sids = *Sids;
 424
 425         Status = LsarLookupNames((LSAPR_HANDLE)PolicyHandle,
 426                                  Count,
 427                                  (PRPC_UNICODE_STRING)Names,
 428                                  (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
 429                                  &TranslatedSids,
 430                                  LsapLookupWksta,
 431                                  &MappedCount);
 432
 433         *Sids = (PLSA_TRANSLATED_SID)TranslatedSids.Sids;
 434     }
 435     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 436     {
 437         if (TranslatedSids.Sids != NULL)
 438         {
 439             MIDL_user_free(TranslatedSids.Sids);
 440         }
 441
 442         Status = I_RpcMapWin32Status(RpcExceptionCode());
 443     }
 444     RpcEndExcept;
 445
 446     return Status;
 447 }
 448
 449 /*
 450  * @unimplemented
 451  */
 452 NTSTATUS
 453 WINAPI
 454 LsaLookupNames2(
 455     LSA_HANDLE PolicyHandle,
 456     ULONG Flags,
 457     ULONG Count,
 458     PLSA_UNICODE_STRING Names,
 459     PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 460     PLSA_TRANSLATED_SID2 *Sids)
 461 {
 462     FIXME("(%p,0x%08x,0x%08x,%p,%p,%p) stub\n", PolicyHandle, Flags,
 463         Count, Names, ReferencedDomains, Sids);
 464     if (Names != NULL && Count > 0)
 465     {
 466         *ReferencedDomains = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(LSA_REFERENCED_DOMAIN_LIST));
 467         *Sids = RtlAllocateHeap(RtlGetProcessHeap(), 0, Count * sizeof(LSA_TRANSLATED_SID2));
 468         return STATUS_SOME_NOT_MAPPED;
 469     }
 470     return STATUS_NONE_MAPPED;
 471 }
 472
 473 /*
 474  * @unmplemented
 475  */
 476 NTSTATUS
 477 WINAPI
 478 LsaLookupPrivilegeName(IN LSA_HANDLE PolicyHandle,
 479                        IN PLUID Value,
 480                        OUT PUNICODE_STRING *Name)
 481 {
 482     PRPC_UNICODE_STRING NameBuffer = NULL;
 483     NTSTATUS Status;
 484
 485     TRACE("(%p,%p,%p)\n", PolicyHandle, Value, Name);
 486
 487     RpcTryExcept
 488     {
 489         Status = LsarLookupPrivilegeName(PolicyHandle,
 490                                          Value,
 491                                          &NameBuffer);
 492
 493         *Name = (PUNICODE_STRING)NameBuffer;
 494     }
 495     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 496     {
 497         if (NameBuffer != NULL)
 498             MIDL_user_free(NameBuffer);
 499
 500         Status = I_RpcMapWin32Status(RpcExceptionCode());
 501     }
 502     RpcEndExcept;
 503
 504     return Status;
 505 }
 506
 507 /*
 508  * @implemented
 509  */
 510 NTSTATUS
 511 WINAPI
 512 LsaLookupPrivilegeValue(IN LSA_HANDLE PolicyHandle,
 513                         IN PLSA_UNICODE_STRING Name,
 514                         OUT PLUID Value)
 515 {
 516     LUID Luid;
 517     NTSTATUS Status;
 518
 519     TRACE("(%p,%p,%p)\n", PolicyHandle, Name, Value);
 520
 521     RpcTryExcept
 522     {
 523         Status = LsarLookupPrivilegeValue(PolicyHandle,
 524                                           (PRPC_UNICODE_STRING)Name,
 525                                           &Luid);
 526         if (Status == STATUS_SUCCESS)
 527             *Value = Luid;
 528     }
 529     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 530     {
 531         Status = I_RpcMapWin32Status(RpcExceptionCode());
 532     }
 533     RpcEndExcept;
 534
 535     return Status;
 536 }
 537
 538 /*
 539  * @implemented
 540  */
 541 NTSTATUS
 542 WINAPI
 543 LsaLookupSids(IN LSA_HANDLE PolicyHandle,
 544               IN ULONG Count,
 545               IN PSID *Sids,
 546               OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 547               OUT PLSA_TRANSLATED_NAME *Names)
 548 {
 549     LSAPR_SID_ENUM_BUFFER SidEnumBuffer;
 550     LSAPR_TRANSLATED_NAMES TranslatedNames;
 551     ULONG MappedCount = 0;
 552     NTSTATUS  Status;
 553
 554     TRACE("(%p,%u,%p,%p,%p)\n", PolicyHandle, Count, Sids,
 555           ReferencedDomains, Names);
 556
 557     if (Count == 0)
 558         return STATUS_INVALID_PARAMETER;
 559
 560     SidEnumBuffer.Entries = Count;
 561     SidEnumBuffer.SidInfo = (PLSAPR_SID_INFORMATION)Sids;
 562
 563     RpcTryExcept
 564     {
 565         *ReferencedDomains = NULL;
 566         *Names = NULL;
 567
 568         TranslatedNames.Entries = 0;
 569         TranslatedNames.Names = NULL;
 570
 571         Status = LsarLookupSids((LSAPR_HANDLE)PolicyHandle,
 572                                 &SidEnumBuffer,
 573                                 (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
 574                                 &TranslatedNames,
 575                                 LsapLookupWksta,
 576                                 &MappedCount);
 577
 578         *Names = (PLSA_TRANSLATED_NAME)TranslatedNames.Names;
 579     }
 580     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 581     {
 582         if (TranslatedNames.Names != NULL)
 583         {
 584             MIDL_user_free(TranslatedNames.Names);
 585         }
 586
 587         Status = I_RpcMapWin32Status(RpcExceptionCode());
 588     }
 589     RpcEndExcept;
 590
 591     return Status;
 592 }
 593
 594 /******************************************************************************
 595  * LsaNtStatusToWinError
 596  *
 597  * PARAMS
 598  *   Status [I]
 599  *
 600  * @implemented
 601  */
 602 ULONG WINAPI
 603 LsaNtStatusToWinError(IN NTSTATUS Status)
 604 {
 605     TRACE("(%lx)\n", Status);
 606     return RtlNtStatusToDosError(Status);
 607 }
 608
 609
 610 /*
 611  * @implemented
 612  */
 613 NTSTATUS
 614 WINAPI
 615 LsaOpenAccount(IN LSA_HANDLE PolicyHandle,
 616                IN PSID AccountSid,
 617                IN ULONG Flags,
 618                OUT PLSA_HANDLE AccountHandle)
 619 {
 620     NTSTATUS Status;
 621
 622     TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, AccountSid, Flags, AccountHandle);
 623
 624     RpcTryExcept
 625     {
 626         Status = LsarOpenAccount((LSAPR_HANDLE)PolicyHandle,
 627                                  AccountSid,
 628                                  Flags,
 629                                  AccountHandle);
 630     }
 631     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 632     {
 633         Status = I_RpcMapWin32Status(RpcExceptionCode());
 634     }
 635     RpcEndExcept;
 636
 637     return Status;
 638 }
 639
 640
 641 /******************************************************************************
 642  * LsaOpenPolicy
 643  *
 644  * PARAMS
 645  *   x1 []
 646  *   x2 []
 647  *   x3 []
 648  *   x4 []
 649  *
 650  * @implemented
 651  */
 652 NTSTATUS
 653 WINAPI
 654 LsaOpenPolicy(IN PLSA_UNICODE_STRING SystemName,
 655               IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
 656               IN ACCESS_MASK DesiredAccess,
 657               OUT PLSA_HANDLE PolicyHandle)
 658 {
 659     NTSTATUS Status;
 660
 661     TRACE("LsaOpenPolicy (%s,%p,0x%08x,%p)\n",
 662           SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
 663           ObjectAttributes, DesiredAccess, PolicyHandle);
 664
 665     /* FIXME: RPC should take care of this */
 666     if (!LsapIsLocalComputer(SystemName))
 667         return RPC_NT_SERVER_UNAVAILABLE;
 668
 669     RpcTryExcept
 670     {
 671         *PolicyHandle = NULL;
 672
 673         Status = LsarOpenPolicy(SystemName ? SystemName->Buffer : NULL,
 674                                 (PLSAPR_OBJECT_ATTRIBUTES)ObjectAttributes,
 675                                 DesiredAccess,
 676                                 PolicyHandle);
 677     }
 678     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 679     {
 680         Status = I_RpcMapWin32Status(RpcExceptionCode());
 681     }
 682     RpcEndExcept;
 683
 684     TRACE("LsaOpenPolicy() done (Status: 0x%08lx)\n", Status);
 685
 686     return Status;
 687 }
 688
 689
 690 /*
 691  * @implemented
 692  */
 693 NTSTATUS
 694 WINAPI
 695 LsaOpenTrustedDomainByName(IN LSA_HANDLE PolicyHandle,
 696                            IN PLSA_UNICODE_STRING TrustedDomainName,
 697                            IN ACCESS_MASK DesiredAccess,
 698                            OUT PLSA_HANDLE TrustedDomainHandle)
 699 {
 700     NTSTATUS Status;
 701
 702     TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, TrustedDomainName,
 703           DesiredAccess, TrustedDomainHandle);
 704
 705     RpcTryExcept
 706     {
 707         Status = LsarOpenTrustedDomainByName((LSAPR_HANDLE)PolicyHandle,
 708                                              (PRPC_UNICODE_STRING)TrustedDomainName,
 709                                              DesiredAccess,
 710                                              TrustedDomainHandle);
 711     }
 712     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 713     {
 714         Status = I_RpcMapWin32Status(RpcExceptionCode());
 715     }
 716     RpcEndExcept;
 717
 718     return Status;
 719 }
 720
 721
 722 /*
 723  * @unimplemented
 724  */
 725 NTSTATUS
 726 WINAPI
 727 LsaQueryDomainInformationPolicy(
 728     LSA_HANDLE PolicyHandle,
 729     POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
 730     PVOID *Buffer)
 731 {
 732     FIXME("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 733     return STATUS_NOT_IMPLEMENTED;
 734 }
 735
 736 /*
 737  * @unimplemented
 738  */
 739 NTSTATUS
 740 WINAPI
 741 LsaQueryForestTrustInformation(
 742     LSA_HANDLE PolicyHandle,
 743     PLSA_UNICODE_STRING TrustedDomainName,
 744     PLSA_FOREST_TRUST_INFORMATION * ForestTrustInfo)
 745 {
 746     FIXME("(%p,%p,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo);
 747     return STATUS_NOT_IMPLEMENTED;
 748 }
 749
 750 /*
 751  * @implemented
 752  */
 753 NTSTATUS
 754 WINAPI
 755 LsaQueryInformationPolicy(IN LSA_HANDLE PolicyHandle,
 756                           IN POLICY_INFORMATION_CLASS InformationClass,
 757                           OUT PVOID *Buffer)
 758 {
 759     PLSAPR_POLICY_INFORMATION PolicyInformation = NULL;
 760     NTSTATUS Status;
 761
 762     TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 763
 764     RpcTryExcept
 765     {
 766         Status = LsarQueryInformationPolicy((LSAPR_HANDLE)PolicyHandle,
 767                                             InformationClass,
 768                                             &PolicyInformation);
 769         *Buffer = PolicyInformation;
 770     }
 771     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 772     {
 773         if (PolicyInformation != NULL)
 774             MIDL_user_free(PolicyInformation);
 775
 776         Status = I_RpcMapWin32Status(RpcExceptionCode());
 777     }
 778     RpcEndExcept;
 779
 780     TRACE("Done (Status: 0x%08x)\n", Status);
 781
 782     return Status;
 783 }
 784
 785 /*
 786  * @unimplemented
 787  */
 788 NTSTATUS
 789 WINAPI
 790 LsaQueryTrustedDomainInfoByName(
 791     LSA_HANDLE PolicyHandle,
 792     PLSA_UNICODE_STRING TrustedDomainName,
 793     TRUSTED_INFORMATION_CLASS InformationClass,
 794     PVOID *Buffer)
 795 {
 796     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
 797     return STATUS_OBJECT_NAME_NOT_FOUND;
 798 }
 799
 800 /*
 801  * @unimplemented
 802  */
 803 NTSTATUS
 804 WINAPI
 805 LsaQueryTrustedDomainInfo(
 806     LSA_HANDLE PolicyHandle,
 807     PSID TrustedDomainSid,
 808     TRUSTED_INFORMATION_CLASS InformationClass,
 809     PVOID *Buffer)
 810 {
 811     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
 812     return STATUS_OBJECT_NAME_NOT_FOUND;
 813 }
 814
 815 /*
 816  * @unimplemented
 817  */
 818 NTSTATUS
 819 WINAPI
 820 LsaRemoveAccountRights(
 821     LSA_HANDLE PolicyHandle,
 822     PSID AccountSid,
 823     BOOLEAN AllRights,
 824     PLSA_UNICODE_STRING UserRights,
 825     ULONG CountOfRights)
 826 {
 827     FIXME("(%p,%p,%d,%p,0x%08x) stub\n", PolicyHandle, AccountSid, AllRights, UserRights, CountOfRights);
 828     return STATUS_SUCCESS;
 829 }
 830
 831 /*
 832  * @unimplemented
 833  */
 834 NTSTATUS
 835 WINAPI
 836 LsaRetrievePrivateData(
 837     LSA_HANDLE PolicyHandle,
 838     PLSA_UNICODE_STRING KeyName,
 839     PLSA_UNICODE_STRING *PrivateData)
 840 {
 841     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 842     return STATUS_OBJECT_NAME_NOT_FOUND;
 843 }
 844
 845 /*
 846  * @unimplemented
 847  */
 848 NTSTATUS
 849 WINAPI
 850 LsaSetDomainInformationPolicy(
 851     LSA_HANDLE PolicyHandle,
 852     POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
 853     PVOID Buffer)
 854 {
 855     FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
 856     return STATUS_UNSUCCESSFUL;
 857 }
 858
 859
 860 /*
 861  * @implemented
 862  */
 863 NTSTATUS
 864 WINAPI
 865 LsaSetInformationPolicy(IN LSA_HANDLE PolicyHandle,
 866                         IN POLICY_INFORMATION_CLASS InformationClass,
 867                         IN PVOID Buffer)
 868 {
 869     NTSTATUS Status;
 870
 871     TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 872
 873     RpcTryExcept
 874     {
 875         Status = LsarSetInformationPolicy((LSAPR_HANDLE)PolicyHandle,
 876                                           InformationClass,
 877                                           (PLSAPR_POLICY_INFORMATION)Buffer);
 878     }
 879     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 880     {
 881         Status = I_RpcMapWin32Status(RpcExceptionCode());
 882     }
 883     RpcEndExcept;
 884
 885     return Status;
 886 }
 887
 888
 889 /*
 890  * @unimplemented
 891  */
 892 NTSTATUS WINAPI LsaSetSecret(
 893     IN LSA_HANDLE SecretHandle,
 894     IN PLSA_UNICODE_STRING EncryptedCurrentValue,
 895     IN PLSA_UNICODE_STRING EncryptedOldValue)
 896 {
 897     FIXME("(%p,%p,%p) stub\n", SecretHandle, EncryptedCurrentValue,
 898             EncryptedOldValue);
 899     return STATUS_SUCCESS;
 900 }
 901
 902 /*
 903  * @unimplemented
 904  */
 905 NTSTATUS
 906 WINAPI
 907 LsaSetForestTrustInformation(
 908     LSA_HANDLE PolicyHandle,
 909     PLSA_UNICODE_STRING TrustedDomainName,
 910     PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
 911     BOOL CheckOnly,
 912     PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
 913 {
 914     FIXME("(%p,%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo, CheckOnly, CollisionInfo);
 915     return STATUS_NOT_IMPLEMENTED;
 916 }
 917
 918 /*
 919  * @unimplemented
 920  */
 921 NTSTATUS
 922 WINAPI
 923 LsaSetTrustedDomainInfoByName(
 924     LSA_HANDLE PolicyHandle,
 925     PLSA_UNICODE_STRING TrustedDomainName,
 926     TRUSTED_INFORMATION_CLASS InformationClass,
 927     PVOID Buffer)
 928 {
 929     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
 930     return STATUS_SUCCESS;
 931 }
 932
 933 /*
 934  * @unimplemented
 935  */
 936 NTSTATUS WINAPI LsaRegisterPolicyChangeNotification(
 937     POLICY_NOTIFICATION_INFORMATION_CLASS class,
 938     HANDLE event)
 939 {
 940     FIXME("(%d,%p) stub\n", class, event);
 941     return STATUS_UNSUCCESSFUL;
 942 }
 943
 944 /*
 945  * @unimplemented
 946  */
 947 NTSTATUS
 948 WINAPI
 949 LsaSetTrustedDomainInformation(
 950     LSA_HANDLE PolicyHandle,
 951     PSID TrustedDomainSid,
 952     TRUSTED_INFORMATION_CLASS InformationClass,
 953     PVOID Buffer)
 954 {
 955     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
 956     return STATUS_SUCCESS;
 957 }
 958
 959 /*
 960  * @unimplemented
 961  */
 962 NTSTATUS
 963 WINAPI
 964 LsaStorePrivateData(
 965     LSA_HANDLE PolicyHandle,
 966     PLSA_UNICODE_STRING KeyName,
 967     PLSA_UNICODE_STRING PrivateData)
 968 {
 969     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 970     return STATUS_OBJECT_NAME_NOT_FOUND;
 971 }
 972
 973 /*
 974  * @unimplemented
 975  */
 976 NTSTATUS WINAPI LsaUnregisterPolicyChangeNotification(
 977     POLICY_NOTIFICATION_INFORMATION_CLASS class,
 978     HANDLE event)
 979 {
 980     FIXME("(%d,%p) stub\n", class, event);
 981     return STATUS_SUCCESS;
 982 }
 983
 984 /*
 985  * @unimplemented
 986  */
 987 NTSTATUS
 988 WINAPI
 989 LsaGetUserName(
 990     PUNICODE_STRING *UserName,
 991     PUNICODE_STRING *DomainName)
 992 {
 993     FIXME("(%p,%p) stub\n", UserName, DomainName);
 994     return STATUS_NOT_IMPLEMENTED;
 995 }
 996
 997 /*
 998  * @unimplemented
 999  */
1000 NTSTATUS
1001 WINAPI
1002 LsaQueryInfoTrustedDomain (DWORD Unknonw0,
1003                            DWORD Unknonw1,
1004                            DWORD Unknonw2)
1005 {
1006     FIXME("(%d,%d,%d) stub\n", Unknonw0, Unknonw1, Unknonw2);
1007     return STATUS_NOT_IMPLEMENTED;
1008 }
1009
1010
1011 /* EOF */