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