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