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