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