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

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS system libraries
   4  * FILE:            lib/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
  14 #include <advapi32.h>
  15 #include "wine/debug.h"
  16
  17 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
  18
  19 static handle_t LSABindingHandle = NULL;
  20
  21 static VOID
  22 LSAHandleUnbind(handle_t *Handle)
  23 {
  24     RPC_STATUS status;
  25
  26     if (*Handle == NULL)
  27         return;
  28
  29     status = RpcBindingFree(Handle);
  30     if (status)
  31     {
  32         TRACE("RpcBindingFree returned 0x%x\n", status);
  33     }
  34 }
  35
  36 static VOID
  37 LSAHandleBind(VOID)
  38 {
  39     LPWSTR pszStringBinding;
  40     RPC_STATUS status;
  41     handle_t Handle;
  42
  43     if (LSABindingHandle != NULL)
  44         return;
  45
  46     status = RpcStringBindingComposeW(NULL,
  47                                       L"ncacn_np",
  48                                       NULL,
  49                                       L"\\pipe\\lsarpc",
  50                                       NULL,
  51                                       &pszStringBinding);
  52     if (status)
  53     {
  54         TRACE("RpcStringBindingCompose returned 0x%x\n", status);
  55         return;
  56     }
  57
  58     /* Set the binding handle that will be used to bind to the server. */
  59     status = RpcBindingFromStringBindingW(pszStringBinding,
  60                                           &Handle);
  61     if (status)
  62     {
  63         TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
  64     }
  65
  66     status = RpcStringFreeW(&pszStringBinding);
  67     if (status)
  68     {
  69         TRACE("RpcStringFree returned 0x%x\n", status);
  70     }
  71
  72     if (InterlockedCompareExchangePointer(&LSABindingHandle,
  73                                           (PVOID)Handle,
  74                                           NULL) != NULL)
  75     {
  76         LSAHandleUnbind(&Handle);
  77     }
  78 }
  79
  80
  81 /*
  82  * @implemented
  83  */
  84 NTSTATUS STDCALL
  85 LsaClose(LSA_HANDLE ObjectHandle)
  86 {
  87     TRACE("LsaClose(0x%p) called\n", ObjectHandle);
  88
  89     /* This is our fake handle, don't go too much long way */
  90     if (ObjectHandle == (LSA_HANDLE)0xcafe)
  91         return STATUS_SUCCESS;
  92
  93     LSAHandleBind();
  94
  95     return LsarClose(LSABindingHandle,
  96                      (unsigned long)ObjectHandle);
  97 }
  98
  99
 100 /*
 101  * @implemented
 102  */
 103 NTSTATUS STDCALL
 104 LsaDelete(LSA_HANDLE ObjectHandle)
 105 {
 106     TRACE("LsaDelete(0x%p) called\n", ObjectHandle);
 107
 108     LSAHandleBind();
 109
 110     return LsarDelete(LSABindingHandle,
 111                       (unsigned long)ObjectHandle);
 112 }
 113
 114
 115 /*
 116  * @unimplemented
 117  */
 118 NTSTATUS
 119 STDCALL
 120 LsaAddAccountRights(
 121     LSA_HANDLE PolicyHandle,
 122     PSID AccountSid,
 123     PLSA_UNICODE_STRING UserRights,
 124     ULONG CountOfRights)
 125 {
 126     FIXME("(%p,%p,%p,0x%08x) stub\n", PolicyHandle, AccountSid, UserRights, CountOfRights);
 127     return STATUS_NOT_IMPLEMENTED;
 128 }
 129
 130 /*
 131  * @unimplemented
 132  */
 133 NTSTATUS
 134 STDCALL
 135 LsaCreateTrustedDomainEx(
 136     LSA_HANDLE PolicyHandle,
 137     PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
 138     PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation,
 139     ACCESS_MASK DesiredAccess,
 140     PLSA_HANDLE TrustedDomainHandle)
 141 {
 142     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, TrustedDomainInformation, AuthenticationInformation,
 143           DesiredAccess, TrustedDomainHandle);
 144     return STATUS_NOT_IMPLEMENTED;
 145 }
 146
 147 /*
 148  * @unimplemented
 149  */
 150 NTSTATUS
 151 STDCALL
 152 LsaDeleteTrustedDomain(
 153     LSA_HANDLE PolicyHandle,
 154     PSID TrustedDomainSid)
 155 {
 156     FIXME("(%p,%p) stub\n", PolicyHandle, TrustedDomainSid);
 157     return STATUS_NOT_IMPLEMENTED;
 158 }
 159
 160 /*
 161  * @unimplemented
 162  */
 163 NTSTATUS
 164 STDCALL
 165 LsaEnumerateAccountRights(
 166     LSA_HANDLE PolicyHandle,
 167     PSID AccountSid,
 168     PLSA_UNICODE_STRING *UserRights,
 169     PULONG CountOfRights)
 170 {
 171     FIXME("(%p,%p,%p,%p) stub\n", PolicyHandle, AccountSid, UserRights, CountOfRights);
 172     return STATUS_NOT_IMPLEMENTED;
 173 }
 174
 175 /*
 176  * @unimplemented
 177  */
 178 NTSTATUS
 179 STDCALL
 180 LsaEnumerateAccountsWithUserRight(
 181     LSA_HANDLE PolicyHandle,
 182     OPTIONAL PLSA_UNICODE_STRING UserRights,
 183     PVOID *EnumerationBuffer,
 184     PULONG CountReturned)
 185 {
 186     FIXME("(%p,%p,%p,%p) stub\n", PolicyHandle, UserRights, EnumerationBuffer, CountReturned);
 187     return STATUS_NOT_IMPLEMENTED;
 188 }
 189
 190 /*
 191  * @unimplemented
 192  */
 193 NTSTATUS
 194 STDCALL
 195 LsaEnumerateTrustedDomains(
 196     LSA_HANDLE PolicyHandle,
 197     PLSA_ENUMERATION_HANDLE EnumerationContext,
 198     PVOID *Buffer,
 199     ULONG PreferedMaximumLength,
 200     PULONG CountReturned)
 201 {
 202     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext,
 203         Buffer, PreferedMaximumLength, CountReturned);
 204     return STATUS_NOT_IMPLEMENTED;
 205 }
 206
 207 /*
 208  * @unimplemented
 209  */
 210 NTSTATUS
 211 STDCALL
 212 LsaEnumerateTrustedDomainsEx(
 213     LSA_HANDLE PolicyHandle,
 214     PLSA_ENUMERATION_HANDLE EnumerationContext,
 215     PVOID *Buffer,
 216     ULONG PreferedMaximumLength,
 217     PULONG CountReturned)
 218 {
 219     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext, Buffer,
 220         PreferedMaximumLength, CountReturned);
 221     return STATUS_NOT_IMPLEMENTED;
 222 }
 223
 224 /*
 225  * @implemented
 226  */
 227 NTSTATUS STDCALL
 228 LsaFreeMemory(PVOID Buffer)
 229 {
 230     TRACE("(%p)\n", Buffer);
 231     return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
 232 }
 233
 234 /*
 235  * @implemented
 236  */
 237 NTSTATUS
 238 WINAPI
 239 LsaLookupNames(
 240     LSA_HANDLE PolicyHandle,
 241     ULONG Count,
 242     PLSA_UNICODE_STRING Names,
 243     PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 244     PLSA_TRANSLATED_SID *Sids)
 245 {
 246     PLSA_TRANSLATED_SID2 Sids2;
 247     LSA_TRANSLATED_SID *TranslatedSids;
 248     ULONG i;
 249     NTSTATUS Status;
 250
 251     TRACE("(%p,0x%08x,%p,%p,%p)\n", PolicyHandle, Count, Names,
 252           ReferencedDomains, Sids);
 253
 254     /* Call LsaLookupNames2, which supersedes this function */
 255     Status = LsaLookupNames2(PolicyHandle, Count, 0, Names, ReferencedDomains, &Sids2);
 256     if (!NT_SUCCESS(Status))
 257         return Status;
 258
 259     /* Translate the returned structure */
 260     TranslatedSids = RtlAllocateHeap(RtlGetProcessHeap(), 0, Count * sizeof(LSA_TRANSLATED_SID));
 261     if (!TranslatedSids)
 262     {
 263         LsaFreeMemory(Sids2);
 264         return SCESTATUS_NOT_ENOUGH_RESOURCE;
 265     }
 266     RtlZeroMemory(Sids, Count * sizeof(PLSA_TRANSLATED_SID));
 267     for (i = 0; i < Count; i++)
 268     {
 269         TranslatedSids[i].Use = Sids2[i].Use;
 270         if (Sids2[i].Use != SidTypeInvalid && Sids2[i].Use != SidTypeUnknown)
 271         {
 272             TranslatedSids[i].DomainIndex = Sids2[i].DomainIndex;
 273             if (Sids2[i].Use != SidTypeDomain)
 274                 TranslatedSids[i].RelativeId = *GetSidSubAuthority(Sids2[i].Sid, 0);
 275         }
 276     }
 277     LsaFreeMemory(Sids2);
 278
 279     *Sids = TranslatedSids;
 280
 281     return Status;
 282 }
 283
 284 /*
 285  * @unimplemented
 286  */
 287 NTSTATUS
 288 STDCALL
 289 LsaLookupNames2(
 290     LSA_HANDLE PolicyHandle,
 291     ULONG Flags,
 292     ULONG Count,
 293     PLSA_UNICODE_STRING Names,
 294     PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 295     PLSA_TRANSLATED_SID2 *Sids)
 296 {
 297     FIXME("(%p,0x%08x,0x%08x,%p,%p,%p) stub\n", PolicyHandle, Flags,
 298         Count, Names, ReferencedDomains, Sids);
 299     return STATUS_NONE_MAPPED;
 300 }
 301
 302 /*
 303  * @unimplemented
 304  */
 305 NTSTATUS
 306 WINAPI
 307 LsaLookupSids(
 308     LSA_HANDLE PolicyHandle,
 309     ULONG Count,
 310     PSID *Sids,
 311     PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 312     PLSA_TRANSLATED_NAME *Names)
 313 {
 314     static const UNICODE_STRING UserName = RTL_CONSTANT_STRING(L"Administrator");
 315     PLSA_REFERENCED_DOMAIN_LIST LocalDomains;
 316     PLSA_TRANSLATED_NAME LocalNames;
 317
 318     FIXME("(%p,%u,%p,%p,%p) stub\n", PolicyHandle, Count, Sids,
 319           ReferencedDomains, Names);
 320
 321     WARN("LsaLookupSids(): stub. Always returning 'Administrator'\n");
 322     if (Count != 1)
 323         return STATUS_NONE_MAPPED;
 324     LocalDomains = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(LSA_TRANSLATED_SID));
 325     if (!LocalDomains)
 326         return SCESTATUS_NOT_ENOUGH_RESOURCE;
 327     LocalNames = RtlAllocateHeap(RtlGetProcessHeap(), 0,  sizeof(LSA_TRANSLATED_NAME) + UserName.MaximumLength);
 328     if (!LocalNames)
 329     {
 330         LsaFreeMemory(LocalDomains);
 331         return SCESTATUS_NOT_ENOUGH_RESOURCE;
 332     }
 333     LocalDomains[0].Entries = 0;
 334     LocalDomains[0].Domains = NULL;
 335     LocalNames[0].Use = SidTypeWellKnownGroup;
 336     LocalNames[0].Name.Buffer = (LPWSTR)((ULONG_PTR)(LocalNames) + sizeof(LSA_TRANSLATED_NAME));
 337     LocalNames[0].Name.Length = UserName.Length;
 338     LocalNames[0].Name.MaximumLength = UserName.MaximumLength;
 339     RtlCopyMemory(LocalNames[0].Name.Buffer, UserName.Buffer, UserName.MaximumLength);
 340
 341     *ReferencedDomains = LocalDomains;
 342     *Names = LocalNames;
 343     return STATUS_SUCCESS;
 344 }
 345
 346 /******************************************************************************
 347  * LsaNtStatusToWinError
 348  *
 349  * PARAMS
 350  *   Status [I]
 351  *
 352  * @implemented
 353  */
 354 ULONG STDCALL
 355 LsaNtStatusToWinError(NTSTATUS Status)
 356 {
 357     TRACE("(%lx)\n", Status);
 358     return RtlNtStatusToDosError(Status);
 359 }
 360
 361 /******************************************************************************
 362  * LsaOpenPolicy
 363  *
 364  * PARAMS
 365  *   x1 []
 366  *   x2 []
 367  *   x3 []
 368  *   x4 []
 369  *
 370  * @unimplemented
 371  */
 372 NTSTATUS
 373 STDCALL
 374 LsaOpenPolicy(
 375     IN PLSA_UNICODE_STRING SystemName,
 376     IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
 377     IN ACCESS_MASK DesiredAccess,
 378     IN OUT PLSA_HANDLE PolicyHandle)
 379 {
 380     FIXME("(%s,%p,0x%08x,%p) stub\n",
 381           SystemName?debugstr_w(SystemName->Buffer):"(null)",
 382           ObjectAttributes, DesiredAccess, PolicyHandle);
 383
 384     if(PolicyHandle) *PolicyHandle = (LSA_HANDLE)0xcafe;
 385     return STATUS_SUCCESS;
 386 }
 387
 388 /*
 389  * @unimplemented
 390  */
 391 NTSTATUS
 392 STDCALL
 393 LsaOpenTrustedDomainByName(
 394     LSA_HANDLE PolicyHandle,
 395     PLSA_UNICODE_STRING TrustedDomainName,
 396     ACCESS_MASK DesiredAccess,
 397     PLSA_HANDLE TrustedDomainHandle)
 398 {
 399     FIXME("(%p,%p,0x%08x,%p) stub\n", PolicyHandle, TrustedDomainName, DesiredAccess, TrustedDomainHandle);
 400     return STATUS_NOT_IMPLEMENTED;
 401 }
 402
 403 /*
 404  * @unimplemented
 405  */
 406 NTSTATUS
 407 STDCALL
 408 LsaQueryDomainInformationPolicy(
 409     LSA_HANDLE PolicyHandle,
 410     POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
 411     PVOID *Buffer)
 412 {
 413     FIXME("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 414     return STATUS_NOT_IMPLEMENTED;
 415 }
 416
 417 /*
 418  * @unimplemented
 419  */
 420 NTSTATUS
 421 STDCALL
 422 LsaQueryForestTrustInformation(
 423     LSA_HANDLE PolicyHandle,
 424     PLSA_UNICODE_STRING TrustedDomainName,
 425     PLSA_FOREST_TRUST_INFORMATION * ForestTrustInfo)
 426 {
 427     FIXME("(%p,%p,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo);
 428     return STATUS_NOT_IMPLEMENTED;
 429 }
 430
 431 /*
 432  * @unimplemented
 433  */
 434 NTSTATUS STDCALL
 435 LsaQueryInformationPolicy(LSA_HANDLE PolicyHandle,
 436                           POLICY_INFORMATION_CLASS pic,
 437                           PVOID *Buffer)
 438 {
 439   FIXME("(%p,0x%08x,%p) stub\n",
 440           PolicyHandle, pic, Buffer);
 441
 442   if (!Buffer)
 443     return FALSE;
 444
 445         switch (pic)
 446         {
 447           case PolicyAuditEventsInformation: /* 2 */
 448             {
 449               PPOLICY_AUDIT_EVENTS_INFO p = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(POLICY_AUDIT_EVENTS_INFO));
 450               p->AuditingMode = FALSE; /* no auditing */
 451               *Buffer = p;
 452             }
 453             break;
 454           case PolicyPrimaryDomainInformation: /* 3 */
 455           case PolicyAccountDomainInformation: /* 5 */
 456             {
 457               struct di
 458               { POLICY_PRIMARY_DOMAIN_INFO ppdi;
 459                 SID sid;
 460               };
 461               SID_IDENTIFIER_AUTHORITY localSidAuthority = {SECURITY_NT_AUTHORITY};
 462
 463               struct di * xdi = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(xdi));
 464               HKEY key;
 465               BOOL useDefault = TRUE;
 466               LONG ret;
 467
 468               if ((ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
 469                "System\\CurrentControlSet\\Services\\VxD\\VNETSUP", 0,
 470                KEY_READ, &key)) == ERROR_SUCCESS)
 471               {
 472                   DWORD size = 0;
 473                   WCHAR wg[] = { 'W','o','r','k','g','r','o','u','p',0 };
 474
 475                   ret = RegQueryValueExW(key, wg, NULL, NULL, NULL, &size);
 476                   if (ret == ERROR_MORE_DATA || ret == ERROR_SUCCESS)
 477                   {
 478                       xdi->ppdi.Name.Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
 479                        HEAP_ZERO_MEMORY, size);
 480                       if ((ret = RegQueryValueExW(key, wg, NULL, NULL,
 481                        (LPBYTE)xdi->ppdi.Name.Buffer, &size)) == ERROR_SUCCESS)
 482                       {
 483                           xdi->ppdi.Name.Length = (USHORT)size;
 484                           useDefault = FALSE;
 485                       }
 486                       else
 487                       {
 488                           RtlFreeHeap(RtlGetProcessHeap(), 0, xdi->ppdi.Name.Buffer);
 489                           xdi->ppdi.Name.Buffer = NULL;
 490                       }
 491                   }
 492                   RegCloseKey(key);
 493               }
 494               if (useDefault)
 495                   RtlCreateUnicodeStringFromAsciiz(&(xdi->ppdi.Name), "DOMAIN");
 496               TRACE("setting domain to \n");
 497
 498               xdi->ppdi.Sid = &(xdi->sid);
 499               xdi->sid.Revision = SID_REVISION;
 500               xdi->sid.SubAuthorityCount = 1;
 501               xdi->sid.IdentifierAuthority = localSidAuthority;
 502               xdi->sid.SubAuthority[0] = SECURITY_LOCAL_SYSTEM_RID;
 503               *Buffer = xdi;
 504             }
 505             break;
 506           case PolicyAuditLogInformation:
 507           case PolicyPdAccountInformation:
 508           case PolicyLsaServerRoleInformation:
 509           case PolicyReplicaSourceInformation:
 510           case PolicyDefaultQuotaInformation:
 511           case PolicyModificationInformation:
 512           case PolicyAuditFullSetInformation:
 513           case PolicyAuditFullQueryInformation:
 514           case PolicyDnsDomainInformation:
 515           case PolicyEfsInformation:
 516             {
 517               FIXME("category not implemented\n");
 518               return FALSE;
 519             }
 520         }
 521         return TRUE;
 522 }
 523
 524 /*
 525  * @unimplemented
 526  */
 527 NTSTATUS
 528 STDCALL
 529 LsaQueryTrustedDomainInfoByName(
 530     LSA_HANDLE PolicyHandle,
 531     PLSA_UNICODE_STRING TrustedDomainName,
 532     TRUSTED_INFORMATION_CLASS InformationClass,
 533     PVOID *Buffer)
 534 {
 535     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
 536     return STATUS_NOT_IMPLEMENTED;
 537 }
 538
 539 /*
 540  * @unimplemented
 541  */
 542 NTSTATUS
 543 STDCALL
 544 LsaQueryTrustedDomainInfo(
 545     LSA_HANDLE PolicyHandle,
 546     PSID TrustedDomainSid,
 547     TRUSTED_INFORMATION_CLASS InformationClass,
 548     PVOID *Buffer)
 549 {
 550     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
 551     return STATUS_NOT_IMPLEMENTED;
 552 }
 553
 554 /*
 555  * @unimplemented
 556  */
 557 NTSTATUS
 558 STDCALL
 559 LsaRemoveAccountRights(
 560     LSA_HANDLE PolicyHandle,
 561     PSID AccountSid,
 562     BOOLEAN AllRights,
 563     PLSA_UNICODE_STRING UserRights,
 564     ULONG CountOfRights)
 565 {
 566     FIXME("(%p,%p,%d,%p,0x%08x) stub\n", PolicyHandle, AccountSid, AllRights, UserRights, CountOfRights);
 567     return STATUS_NOT_IMPLEMENTED;
 568 }
 569
 570 /*
 571  * @unimplemented
 572  */
 573 NTSTATUS
 574 STDCALL
 575 LsaRetrievePrivateData(
 576     LSA_HANDLE PolicyHandle,
 577     PLSA_UNICODE_STRING KeyName,
 578     PLSA_UNICODE_STRING *PrivateData)
 579 {
 580     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 581     return STATUS_NOT_IMPLEMENTED;
 582 }
 583
 584 /*
 585  * @unimplemented
 586  */
 587 NTSTATUS
 588 STDCALL
 589 LsaSetDomainInformationPolicy(
 590     LSA_HANDLE PolicyHandle,
 591     POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
 592     PVOID Buffer)
 593 {
 594     FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
 595     return STATUS_NOT_IMPLEMENTED;
 596 }
 597
 598 /*
 599  * @unimplemented
 600  */
 601 NTSTATUS
 602 STDCALL
 603 LsaSetInformationPolicy(
 604     LSA_HANDLE PolicyHandle,
 605     POLICY_INFORMATION_CLASS InformationClass,
 606     PVOID Buffer)
 607 {
 608     FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
 609     return STATUS_NOT_IMPLEMENTED;
 610 }
 611
 612 /*
 613  * @unimplemented
 614  */
 615 NTSTATUS
 616 STDCALL
 617 LsaSetForestTrustInformation(
 618     LSA_HANDLE PolicyHandle,
 619     PLSA_UNICODE_STRING TrustedDomainName,
 620     PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
 621     BOOL CheckOnly,
 622     PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
 623 {
 624     FIXME("(%p,%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo, CheckOnly, CollisionInfo);
 625     return STATUS_NOT_IMPLEMENTED;
 626 }
 627
 628 /*
 629  * @unimplemented
 630  */
 631 NTSTATUS
 632 STDCALL
 633 LsaSetTrustedDomainInfoByName(
 634     LSA_HANDLE PolicyHandle,
 635     PLSA_UNICODE_STRING TrustedDomainName,
 636     TRUSTED_INFORMATION_CLASS InformationClass,
 637     PVOID Buffer)
 638 {
 639     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
 640     return STATUS_NOT_IMPLEMENTED;
 641 }
 642
 643 /*
 644  * @unimplemented
 645  */
 646 NTSTATUS
 647 STDCALL
 648 LsaSetTrustedDomainInformation(
 649     LSA_HANDLE PolicyHandle,
 650     PSID TrustedDomainSid,
 651     TRUSTED_INFORMATION_CLASS InformationClass,
 652     PVOID Buffer)
 653 {
 654     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
 655     return STATUS_NOT_IMPLEMENTED;
 656 }
 657
 658 /*
 659  * @unimplemented
 660  */
 661 NTSTATUS
 662 STDCALL
 663 LsaStorePrivateData(
 664     LSA_HANDLE PolicyHandle,
 665     PLSA_UNICODE_STRING KeyName,
 666     PLSA_UNICODE_STRING PrivateData)
 667 {
 668     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 669     return STATUS_NOT_IMPLEMENTED;
 670 }
 671
 672 /*
 673  * @unimplemented
 674  */
 675 NTSTATUS
 676 STDCALL
 677 LsaGetUserName(
 678     PUNICODE_STRING *UserName,
 679     PUNICODE_STRING *DomainName)
 680 {
 681     FIXME("(%p,%p) stub\n", UserName, DomainName);
 682     return STATUS_NOT_IMPLEMENTED;
 683 }
 684
 685 /*
 686  * @unimplemented
 687  */
 688 NTSTATUS
 689 STDCALL
 690 LsaQueryInfoTrustedDomain (DWORD Unknonw0,
 691                            DWORD Unknonw1,
 692                            DWORD Unknonw2)
 693 {
 694     FIXME("(%d,%d,%d) stub\n", Unknonw0, Unknonw1, Unknonw2);
 695     return STATUS_NOT_IMPLEMENTED;
 696 }
 697
 698
 699 /* EOF */