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;
 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     RpcTryExcept
 441     {
 442         *ReferencedDomains = NULL;
 443         *Sids = NULL;
 444
 445         TranslatedSids.Entries = Count;
 446         TranslatedSids.Sids = *Sids;
 447
 448         Status = LsarLookupNames((LSAPR_HANDLE)PolicyHandle,
 449                                  Count,
 450                                  (PRPC_UNICODE_STRING)Names,
 451                                  (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
 452                                  &TranslatedSids,
 453                                  LsapLookupWksta,
 454                                  &MappedCount);
 455
 456         *Sids = (PLSA_TRANSLATED_SID)TranslatedSids.Sids;
 457     }
 458     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 459     {
 460         if (TranslatedSids.Sids != NULL)
 461         {
 462             MIDL_user_free(TranslatedSids.Sids);
 463         }
 464
 465         Status = I_RpcMapWin32Status(RpcExceptionCode());
 466     }
 467     RpcEndExcept;
 468
 469     return Status;
 470 }
 471
 472
 473 /*
 474  * @unimplemented
 475  */
 476 NTSTATUS
 477 WINAPI
 478 LsaLookupNames2(
 479     LSA_HANDLE PolicyHandle,
 480     ULONG Flags,
 481     ULONG Count,
 482     PLSA_UNICODE_STRING Names,
 483     PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 484     PLSA_TRANSLATED_SID2 *Sids)
 485 {
 486     FIXME("(%p,0x%08x,0x%08x,%p,%p,%p) stub\n", PolicyHandle, Flags,
 487         Count, Names, ReferencedDomains, Sids);
 488     if (Names != NULL && Count > 0)
 489     {
 490         *ReferencedDomains = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(LSA_REFERENCED_DOMAIN_LIST));
 491         *Sids = RtlAllocateHeap(RtlGetProcessHeap(), 0, Count * sizeof(LSA_TRANSLATED_SID2));
 492         return STATUS_SOME_NOT_MAPPED;
 493     }
 494     return STATUS_NONE_MAPPED;
 495 }
 496
 497
 498 /*
 499  * @implemented
 500  */
 501 NTSTATUS
 502 WINAPI
 503 LsaLookupPrivilegeName(IN LSA_HANDLE PolicyHandle,
 504                        IN PLUID Value,
 505                        OUT PUNICODE_STRING *Name)
 506 {
 507     PRPC_UNICODE_STRING NameBuffer = NULL;
 508     NTSTATUS Status;
 509
 510     TRACE("(%p,%p,%p)\n", PolicyHandle, Value, Name);
 511
 512     RpcTryExcept
 513     {
 514         Status = LsarLookupPrivilegeName(PolicyHandle,
 515                                          Value,
 516                                          &NameBuffer);
 517
 518         *Name = (PUNICODE_STRING)NameBuffer;
 519     }
 520     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 521     {
 522         if (NameBuffer != NULL)
 523             MIDL_user_free(NameBuffer);
 524
 525         Status = I_RpcMapWin32Status(RpcExceptionCode());
 526     }
 527     RpcEndExcept;
 528
 529     return Status;
 530 }
 531
 532
 533 /*
 534  * @implemented
 535  */
 536 NTSTATUS
 537 WINAPI
 538 LsaLookupPrivilegeValue(IN LSA_HANDLE PolicyHandle,
 539                         IN PLSA_UNICODE_STRING Name,
 540                         OUT PLUID Value)
 541 {
 542     LUID Luid;
 543     NTSTATUS Status;
 544
 545     TRACE("(%p,%p,%p)\n", PolicyHandle, Name, Value);
 546
 547     RpcTryExcept
 548     {
 549         Status = LsarLookupPrivilegeValue(PolicyHandle,
 550                                           (PRPC_UNICODE_STRING)Name,
 551                                           &Luid);
 552         if (Status == STATUS_SUCCESS)
 553             *Value = Luid;
 554     }
 555     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 556     {
 557         Status = I_RpcMapWin32Status(RpcExceptionCode());
 558     }
 559     RpcEndExcept;
 560
 561     return Status;
 562 }
 563
 564
 565 /*
 566  * @implemented
 567  */
 568 NTSTATUS
 569 WINAPI
 570 LsaLookupSids(IN LSA_HANDLE PolicyHandle,
 571               IN ULONG Count,
 572               IN PSID *Sids,
 573               OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 574               OUT PLSA_TRANSLATED_NAME *Names)
 575 {
 576     LSAPR_SID_ENUM_BUFFER SidEnumBuffer;
 577     LSAPR_TRANSLATED_NAMES TranslatedNames;
 578     ULONG MappedCount = 0;
 579     NTSTATUS  Status;
 580
 581     TRACE("(%p,%u,%p,%p,%p)\n", PolicyHandle, Count, Sids,
 582           ReferencedDomains, Names);
 583
 584     if (Count == 0)
 585         return STATUS_INVALID_PARAMETER;
 586
 587     SidEnumBuffer.Entries = Count;
 588     SidEnumBuffer.SidInfo = (PLSAPR_SID_INFORMATION)Sids;
 589
 590     RpcTryExcept
 591     {
 592         *ReferencedDomains = NULL;
 593         *Names = NULL;
 594
 595         TranslatedNames.Entries = 0;
 596         TranslatedNames.Names = NULL;
 597
 598         Status = LsarLookupSids((LSAPR_HANDLE)PolicyHandle,
 599                                 &SidEnumBuffer,
 600                                 (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
 601                                 &TranslatedNames,
 602                                 LsapLookupWksta,
 603                                 &MappedCount);
 604
 605         *Names = (PLSA_TRANSLATED_NAME)TranslatedNames.Names;
 606     }
 607     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 608     {
 609         if (TranslatedNames.Names != NULL)
 610         {
 611             MIDL_user_free(TranslatedNames.Names);
 612         }
 613
 614         Status = I_RpcMapWin32Status(RpcExceptionCode());
 615     }
 616     RpcEndExcept;
 617
 618     return Status;
 619 }
 620
 621
 622 /******************************************************************************
 623  * LsaNtStatusToWinError
 624  *
 625  * PARAMS
 626  *   Status [I]
 627  *
 628  * @implemented
 629  */
 630 ULONG
 631 WINAPI
 632 LsaNtStatusToWinError(IN NTSTATUS Status)
 633 {
 634     TRACE("(%lx)\n", Status);
 635     return RtlNtStatusToDosError(Status);
 636 }
 637
 638
 639 /*
 640  * @implemented
 641  */
 642 NTSTATUS
 643 WINAPI
 644 LsaOpenAccount(IN LSA_HANDLE PolicyHandle,
 645                IN PSID AccountSid,
 646                IN ULONG Flags,
 647                OUT PLSA_HANDLE AccountHandle)
 648 {
 649     NTSTATUS Status;
 650
 651     TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, AccountSid, Flags, AccountHandle);
 652
 653     RpcTryExcept
 654     {
 655         Status = LsarOpenAccount((LSAPR_HANDLE)PolicyHandle,
 656                                  AccountSid,
 657                                  Flags,
 658                                  AccountHandle);
 659     }
 660     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 661     {
 662         Status = I_RpcMapWin32Status(RpcExceptionCode());
 663     }
 664     RpcEndExcept;
 665
 666     return Status;
 667 }
 668
 669
 670 /******************************************************************************
 671  * LsaOpenPolicy
 672  *
 673  * PARAMS
 674  *   x1 []
 675  *   x2 []
 676  *   x3 []
 677  *   x4 []
 678  *
 679  * @implemented
 680  */
 681 NTSTATUS
 682 WINAPI
 683 LsaOpenPolicy(IN PLSA_UNICODE_STRING SystemName,
 684               IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
 685               IN ACCESS_MASK DesiredAccess,
 686               OUT PLSA_HANDLE PolicyHandle)
 687 {
 688     NTSTATUS Status;
 689
 690     TRACE("LsaOpenPolicy (%s,%p,0x%08x,%p)\n",
 691           SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
 692           ObjectAttributes, DesiredAccess, PolicyHandle);
 693
 694     /* FIXME: RPC should take care of this */
 695     if (!LsapIsLocalComputer(SystemName))
 696         return RPC_NT_SERVER_UNAVAILABLE;
 697
 698     RpcTryExcept
 699     {
 700         *PolicyHandle = NULL;
 701
 702         Status = LsarOpenPolicy(SystemName ? SystemName->Buffer : NULL,
 703                                 (PLSAPR_OBJECT_ATTRIBUTES)ObjectAttributes,
 704                                 DesiredAccess,
 705                                 PolicyHandle);
 706     }
 707     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 708     {
 709         Status = I_RpcMapWin32Status(RpcExceptionCode());
 710     }
 711     RpcEndExcept;
 712
 713     TRACE("LsaOpenPolicy() done (Status: 0x%08lx)\n", Status);
 714
 715     return Status;
 716 }
 717
 718
 719 /*
 720  * @implemented
 721  */
 722 NTSTATUS
 723 WINAPI
 724 LsaOpenTrustedDomainByName(IN LSA_HANDLE PolicyHandle,
 725                            IN PLSA_UNICODE_STRING TrustedDomainName,
 726                            IN ACCESS_MASK DesiredAccess,
 727                            OUT PLSA_HANDLE TrustedDomainHandle)
 728 {
 729     NTSTATUS Status;
 730
 731     TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, TrustedDomainName,
 732           DesiredAccess, TrustedDomainHandle);
 733
 734     RpcTryExcept
 735     {
 736         Status = LsarOpenTrustedDomainByName((LSAPR_HANDLE)PolicyHandle,
 737                                              (PRPC_UNICODE_STRING)TrustedDomainName,
 738                                              DesiredAccess,
 739                                              TrustedDomainHandle);
 740     }
 741     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 742     {
 743         Status = I_RpcMapWin32Status(RpcExceptionCode());
 744     }
 745     RpcEndExcept;
 746
 747     return Status;
 748 }
 749
 750
 751 /*
 752  * @unimplemented
 753  */
 754 NTSTATUS
 755 WINAPI
 756 LsaQueryDomainInformationPolicy(
 757     LSA_HANDLE PolicyHandle,
 758     POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
 759     PVOID *Buffer)
 760 {
 761     FIXME("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 762     return STATUS_NOT_IMPLEMENTED;
 763 }
 764
 765 /*
 766  * @unimplemented
 767  */
 768 NTSTATUS
 769 WINAPI
 770 LsaQueryForestTrustInformation(
 771     LSA_HANDLE PolicyHandle,
 772     PLSA_UNICODE_STRING TrustedDomainName,
 773     PLSA_FOREST_TRUST_INFORMATION * ForestTrustInfo)
 774 {
 775     FIXME("(%p,%p,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo);
 776     return STATUS_NOT_IMPLEMENTED;
 777 }
 778
 779
 780 /*
 781  * @implemented
 782  */
 783 NTSTATUS
 784 WINAPI
 785 LsaQueryInformationPolicy(IN LSA_HANDLE PolicyHandle,
 786                           IN POLICY_INFORMATION_CLASS InformationClass,
 787                           OUT PVOID *Buffer)
 788 {
 789     PLSAPR_POLICY_INFORMATION PolicyInformation = NULL;
 790     NTSTATUS Status;
 791
 792     TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 793
 794     RpcTryExcept
 795     {
 796         Status = LsarQueryInformationPolicy((LSAPR_HANDLE)PolicyHandle,
 797                                             InformationClass,
 798                                             &PolicyInformation);
 799         *Buffer = PolicyInformation;
 800     }
 801     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 802     {
 803         if (PolicyInformation != NULL)
 804             MIDL_user_free(PolicyInformation);
 805
 806         Status = I_RpcMapWin32Status(RpcExceptionCode());
 807     }
 808     RpcEndExcept;
 809
 810     TRACE("Done (Status: 0x%08x)\n", Status);
 811
 812     return Status;
 813 }
 814
 815
 816 /*
 817  * @unimplemented
 818  */
 819 NTSTATUS
 820 WINAPI
 821 LsaQueryTrustedDomainInfo(
 822     LSA_HANDLE PolicyHandle,
 823     PSID TrustedDomainSid,
 824     TRUSTED_INFORMATION_CLASS InformationClass,
 825     PVOID *Buffer)
 826 {
 827     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
 828     return STATUS_OBJECT_NAME_NOT_FOUND;
 829 }
 830
 831
 832 /*
 833  * @implemented
 834  */
 835 NTSTATUS
 836 WINAPI
 837 LsaQueryTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle,
 838                                 IN PLSA_UNICODE_STRING TrustedDomainName,
 839                                 IN TRUSTED_INFORMATION_CLASS InformationClass,
 840                                 OUT PVOID *Buffer)
 841 {
 842     NTSTATUS Status;
 843
 844     TRACE("(%p,%p,%d,%p)\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
 845
 846     if (InformationClass == 9 /*TrustedDomainAuthInformationInternal*/ ||
 847         InformationClass == 10 /*TrustedDomainFullInformationInternal*/)
 848         return STATUS_INVALID_INFO_CLASS;
 849
 850     RpcTryExcept
 851     {
 852         Status = LsarQueryTrustedDomainInfoByName((LSAPR_HANDLE)PolicyHandle,
 853                                                   (PRPC_UNICODE_STRING)TrustedDomainName,
 854                                                   InformationClass,
 855                                                   (unsigned long *)Buffer); // Shuld be: (PLSAPR_POLICY_INFORMATION *)Buffer
 856     }
 857     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 858     {
 859         Status = I_RpcMapWin32Status(RpcExceptionCode());
 860     }
 861     RpcEndExcept;
 862
 863     return Status;
 864 }
 865
 866
 867 /*
 868  * @implemented
 869  */
 870 NTSTATUS
 871 WINAPI
 872 LsaRemoveAccountRights(IN LSA_HANDLE PolicyHandle,
 873                        IN PSID AccountSid,
 874                        IN BOOLEAN AllRights,
 875                        IN PLSA_UNICODE_STRING UserRights,
 876                        IN ULONG CountOfRights)
 877 {
 878     LSAPR_USER_RIGHT_SET UserRightSet;
 879     NTSTATUS Status;
 880
 881     TRACE("(%p,%p,%d,%p,0x%08x) stub\n", PolicyHandle, AccountSid, AllRights, UserRights, CountOfRights);
 882
 883     UserRightSet.Entries = CountOfRights;
 884     UserRightSet.UserRights = (PRPC_UNICODE_STRING)UserRights;
 885
 886     RpcTryExcept
 887     {
 888         Status = LsarRemoveAccountRights((LSAPR_HANDLE)PolicyHandle,
 889                                          (PRPC_SID)AccountSid,
 890                                          AllRights,
 891                                          &UserRightSet);
 892     }
 893     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 894     {
 895         Status = I_RpcMapWin32Status(RpcExceptionCode());
 896     }
 897     RpcEndExcept;
 898
 899     return STATUS_SUCCESS;
 900 }
 901
 902
 903 /*
 904  * @unimplemented
 905  */
 906 NTSTATUS
 907 WINAPI
 908 LsaRetrievePrivateData(
 909     LSA_HANDLE PolicyHandle,
 910     PLSA_UNICODE_STRING KeyName,
 911     PLSA_UNICODE_STRING *PrivateData)
 912 {
 913     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 914     return STATUS_OBJECT_NAME_NOT_FOUND;
 915 }
 916
 917 /*
 918  * @unimplemented
 919  */
 920 NTSTATUS
 921 WINAPI
 922 LsaSetDomainInformationPolicy(
 923     LSA_HANDLE PolicyHandle,
 924     POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
 925     PVOID Buffer)
 926 {
 927     FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
 928     return STATUS_UNSUCCESSFUL;
 929 }
 930
 931
 932 /*
 933  * @implemented
 934  */
 935 NTSTATUS
 936 WINAPI
 937 LsaSetInformationPolicy(IN LSA_HANDLE PolicyHandle,
 938                         IN POLICY_INFORMATION_CLASS InformationClass,
 939                         IN PVOID Buffer)
 940 {
 941     NTSTATUS Status;
 942
 943     TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 944
 945     RpcTryExcept
 946     {
 947         Status = LsarSetInformationPolicy((LSAPR_HANDLE)PolicyHandle,
 948                                           InformationClass,
 949                                           (PLSAPR_POLICY_INFORMATION)Buffer);
 950     }
 951     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 952     {
 953         Status = I_RpcMapWin32Status(RpcExceptionCode());
 954     }
 955     RpcEndExcept;
 956
 957     return Status;
 958 }
 959
 960
 961 /*
 962  * @unimplemented
 963  */
 964 NTSTATUS WINAPI LsaSetSecret(
 965     IN LSA_HANDLE SecretHandle,
 966     IN PLSA_UNICODE_STRING EncryptedCurrentValue,
 967     IN PLSA_UNICODE_STRING EncryptedOldValue)
 968 {
 969     FIXME("(%p,%p,%p) stub\n", SecretHandle, EncryptedCurrentValue,
 970             EncryptedOldValue);
 971     return STATUS_SUCCESS;
 972 }
 973
 974 /*
 975  * @unimplemented
 976  */
 977 NTSTATUS
 978 WINAPI
 979 LsaSetForestTrustInformation(
 980     LSA_HANDLE PolicyHandle,
 981     PLSA_UNICODE_STRING TrustedDomainName,
 982     PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
 983     BOOL CheckOnly,
 984     PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
 985 {
 986     FIXME("(%p,%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo, CheckOnly, CollisionInfo);
 987     return STATUS_NOT_IMPLEMENTED;
 988 }
 989
 990 /*
 991  * @unimplemented
 992  */
 993 NTSTATUS
 994 WINAPI
 995 LsaSetTrustedDomainInfoByName(
 996     LSA_HANDLE PolicyHandle,
 997     PLSA_UNICODE_STRING TrustedDomainName,
 998     TRUSTED_INFORMATION_CLASS InformationClass,
 999     PVOID Buffer)
1000 {
1001     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
1002     return STATUS_SUCCESS;
1003 }
1004
1005 /*
1006  * @unimplemented
1007  */
1008 NTSTATUS WINAPI LsaRegisterPolicyChangeNotification(
1009     POLICY_NOTIFICATION_INFORMATION_CLASS class,
1010     HANDLE event)
1011 {
1012     FIXME("(%d,%p) stub\n", class, event);
1013     return STATUS_UNSUCCESSFUL;
1014 }
1015
1016 /*
1017  * @unimplemented
1018  */
1019 NTSTATUS
1020 WINAPI
1021 LsaSetTrustedDomainInformation(
1022     LSA_HANDLE PolicyHandle,
1023     PSID TrustedDomainSid,
1024     TRUSTED_INFORMATION_CLASS InformationClass,
1025     PVOID Buffer)
1026 {
1027     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
1028     return STATUS_SUCCESS;
1029 }
1030
1031 /*
1032  * @unimplemented
1033  */
1034 NTSTATUS
1035 WINAPI
1036 LsaStorePrivateData(
1037     LSA_HANDLE PolicyHandle,
1038     PLSA_UNICODE_STRING KeyName,
1039     PLSA_UNICODE_STRING PrivateData)
1040 {
1041     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
1042     return STATUS_OBJECT_NAME_NOT_FOUND;
1043 }
1044
1045 /*
1046  * @unimplemented
1047  */
1048 NTSTATUS WINAPI LsaUnregisterPolicyChangeNotification(
1049     POLICY_NOTIFICATION_INFORMATION_CLASS class,
1050     HANDLE event)
1051 {
1052     FIXME("(%d,%p) stub\n", class, event);
1053     return STATUS_SUCCESS;
1054 }
1055
1056 /*
1057  * @unimplemented
1058  */
1059 NTSTATUS
1060 WINAPI
1061 LsaGetUserName(
1062     PUNICODE_STRING *UserName,
1063     PUNICODE_STRING *DomainName)
1064 {
1065     FIXME("(%p,%p) stub\n", UserName, DomainName);
1066     return STATUS_NOT_IMPLEMENTED;
1067 }
1068
1069 /*
1070  * @unimplemented
1071  */
1072 NTSTATUS
1073 WINAPI
1074 LsaQueryInfoTrustedDomain (DWORD Unknonw0,
1075                            DWORD Unknonw1,
1076                            DWORD Unknonw2)
1077 {
1078     FIXME("(%d,%d,%d) stub\n", Unknonw0, Unknonw1, Unknonw2);
1079     return STATUS_NOT_IMPLEMENTED;
1080 }
1081
1082
1083 /* EOF */