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_NOT_IMPLEMENTED;
 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_NOT_IMPLEMENTED;
 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     return STATUS_NOT_IMPLEMENTED;
 232 }
 233
 234 /*
 235  * @unimplemented
 236  */
 237 NTSTATUS
 238 WINAPI
 239 LsaEnumerateAccountsWithUserRight(
 240     LSA_HANDLE PolicyHandle,
 241     OPTIONAL PLSA_UNICODE_STRING UserRights,
 242     PVOID *EnumerationBuffer,
 243     PULONG CountReturned)
 244 {
 245     FIXME("(%p,%p,%p,%p) stub\n", PolicyHandle, UserRights, EnumerationBuffer, CountReturned);
 246     return STATUS_NOT_IMPLEMENTED;
 247 }
 248
 249 /*
 250  * @unimplemented
 251  */
 252 NTSTATUS
 253 WINAPI
 254 LsaEnumerateTrustedDomains(
 255     LSA_HANDLE PolicyHandle,
 256     PLSA_ENUMERATION_HANDLE EnumerationContext,
 257     PVOID *Buffer,
 258     ULONG PreferedMaximumLength,
 259     PULONG CountReturned)
 260 {
 261     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext,
 262         Buffer, PreferedMaximumLength, CountReturned);
 263     return STATUS_NOT_IMPLEMENTED;
 264 }
 265
 266 /*
 267  * @unimplemented
 268  */
 269 NTSTATUS
 270 WINAPI
 271 LsaEnumerateTrustedDomainsEx(
 272     LSA_HANDLE PolicyHandle,
 273     PLSA_ENUMERATION_HANDLE EnumerationContext,
 274     PVOID *Buffer,
 275     ULONG PreferedMaximumLength,
 276     PULONG CountReturned)
 277 {
 278     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext, Buffer,
 279         PreferedMaximumLength, CountReturned);
 280     return STATUS_NOT_IMPLEMENTED;
 281 }
 282
 283 /*
 284  * @implemented
 285  */
 286 NTSTATUS 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(
 299     LSA_HANDLE PolicyHandle,
 300     ULONG Count,
 301     PLSA_UNICODE_STRING Names,
 302     PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 303     PLSA_TRANSLATED_SID *Sids)
 304 {
 305     PLSA_TRANSLATED_SID2 Sids2;
 306     LSA_TRANSLATED_SID *TranslatedSids;
 307     ULONG i;
 308     NTSTATUS Status;
 309
 310     TRACE("(%p,0x%08x,%p,%p,%p)\n", PolicyHandle, Count, Names,
 311           ReferencedDomains, Sids);
 312
 313     /* Call LsaLookupNames2, which supersedes this function */
 314     Status = LsaLookupNames2(PolicyHandle, Count, 0, Names, ReferencedDomains, &Sids2);
 315     if (!NT_SUCCESS(Status))
 316         return Status;
 317
 318     /* Translate the returned structure */
 319     TranslatedSids = RtlAllocateHeap(RtlGetProcessHeap(), 0, Count * sizeof(LSA_TRANSLATED_SID));
 320     if (!TranslatedSids)
 321     {
 322         LsaFreeMemory(Sids2);
 323         return SCESTATUS_NOT_ENOUGH_RESOURCE;
 324     }
 325     RtlZeroMemory(Sids, Count * sizeof(PLSA_TRANSLATED_SID));
 326     for (i = 0; i < Count; i++)
 327     {
 328         TranslatedSids[i].Use = Sids2[i].Use;
 329         if (Sids2[i].Use != SidTypeInvalid && Sids2[i].Use != SidTypeUnknown)
 330         {
 331             TranslatedSids[i].DomainIndex = Sids2[i].DomainIndex;
 332             if (Sids2[i].Use != SidTypeDomain)
 333                 TranslatedSids[i].RelativeId = *GetSidSubAuthority(Sids2[i].Sid, 0);
 334         }
 335     }
 336     LsaFreeMemory(Sids2);
 337
 338     *Sids = TranslatedSids;
 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     return STATUS_NONE_MAPPED;
 359 }
 360
 361 /*
 362  * @unimplemented
 363  */
 364 NTSTATUS
 365 WINAPI
 366 LsaLookupSids(
 367     LSA_HANDLE PolicyHandle,
 368     ULONG Count,
 369     PSID *Sids,
 370     PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 371     PLSA_TRANSLATED_NAME *Names)
 372 {
 373     static const UNICODE_STRING UserName = RTL_CONSTANT_STRING(L"Administrator");
 374     PLSA_REFERENCED_DOMAIN_LIST LocalDomains;
 375     PLSA_TRANSLATED_NAME LocalNames;
 376
 377     TRACE("(%p,%u,%p,%p,%p) stub\n", PolicyHandle, Count, Sids,
 378           ReferencedDomains, Names);
 379
 380     WARN("LsaLookupSids(): stub. Always returning 'Administrator'\n");
 381     if (Count != 1)
 382         return STATUS_NONE_MAPPED;
 383     LocalDomains = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(LSA_TRANSLATED_SID));
 384     if (!LocalDomains)
 385         return SCESTATUS_NOT_ENOUGH_RESOURCE;
 386     LocalNames = RtlAllocateHeap(RtlGetProcessHeap(), 0,  sizeof(LSA_TRANSLATED_NAME) + UserName.MaximumLength);
 387     if (!LocalNames)
 388     {
 389         LsaFreeMemory(LocalDomains);
 390         return SCESTATUS_NOT_ENOUGH_RESOURCE;
 391     }
 392     LocalDomains[0].Entries = 0;
 393     LocalDomains[0].Domains = NULL;
 394     LocalNames[0].Use = SidTypeWellKnownGroup;
 395     LocalNames[0].Name.Buffer = (LPWSTR)((ULONG_PTR)(LocalNames) + sizeof(LSA_TRANSLATED_NAME));
 396     LocalNames[0].Name.Length = UserName.Length;
 397     LocalNames[0].Name.MaximumLength = UserName.MaximumLength;
 398     RtlCopyMemory(LocalNames[0].Name.Buffer, UserName.Buffer, UserName.MaximumLength);
 399
 400     *ReferencedDomains = LocalDomains;
 401     *Names = LocalNames;
 402     return STATUS_SUCCESS;
 403 }
 404
 405 /******************************************************************************
 406  * LsaNtStatusToWinError
 407  *
 408  * PARAMS
 409  *   Status [I]
 410  *
 411  * @implemented
 412  */
 413 ULONG WINAPI
 414 LsaNtStatusToWinError(NTSTATUS Status)
 415 {
 416     TRACE("(%lx)\n", Status);
 417     return RtlNtStatusToDosError(Status);
 418 }
 419
 420 /******************************************************************************
 421  * LsaOpenPolicy
 422  *
 423  * PARAMS
 424  *   x1 []
 425  *   x2 []
 426  *   x3 []
 427  *   x4 []
 428  *
 429  * @unimplemented
 430  */
 431 NTSTATUS
 432 WINAPI
 433 LsaOpenPolicy(
 434     IN PLSA_UNICODE_STRING SystemName,
 435     IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
 436     IN ACCESS_MASK DesiredAccess,
 437     IN OUT PLSA_HANDLE PolicyHandle)
 438 {
 439     NTSTATUS Status;
 440
 441     TRACE("LsaOpenPolicy (%s,%p,0x%08x,%p)\n",
 442           SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
 443           ObjectAttributes, DesiredAccess, PolicyHandle);
 444
 445     RpcTryExcept
 446     {
 447         *PolicyHandle = NULL;
 448
 449         Status = LsarOpenPolicy(SystemName ? SystemName->Buffer : NULL,
 450                                 (PLSAPR_OBJECT_ATTRIBUTES)ObjectAttributes,
 451                                 DesiredAccess,
 452                                 PolicyHandle);
 453     }
 454     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 455     {
 456         Status = I_RpcMapWin32Status(RpcExceptionCode());
 457     }
 458     RpcEndExcept;
 459
 460     TRACE("LsaOpenPolicy() done (Status: 0x%08lx)\n", Status);
 461
 462     return Status;
 463 }
 464
 465
 466 /*
 467  * @unimplemented
 468  */
 469 NTSTATUS
 470 WINAPI
 471 LsaOpenTrustedDomainByName(
 472     LSA_HANDLE PolicyHandle,
 473     PLSA_UNICODE_STRING TrustedDomainName,
 474     ACCESS_MASK DesiredAccess,
 475     PLSA_HANDLE TrustedDomainHandle)
 476 {
 477     FIXME("(%p,%p,0x%08x,%p) stub\n", PolicyHandle, TrustedDomainName, DesiredAccess, TrustedDomainHandle);
 478     return STATUS_NOT_IMPLEMENTED;
 479 }
 480
 481 /*
 482  * @unimplemented
 483  */
 484 NTSTATUS
 485 WINAPI
 486 LsaQueryDomainInformationPolicy(
 487     LSA_HANDLE PolicyHandle,
 488     POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
 489     PVOID *Buffer)
 490 {
 491     FIXME("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 492     return STATUS_NOT_IMPLEMENTED;
 493 }
 494
 495 /*
 496  * @unimplemented
 497  */
 498 NTSTATUS
 499 WINAPI
 500 LsaQueryForestTrustInformation(
 501     LSA_HANDLE PolicyHandle,
 502     PLSA_UNICODE_STRING TrustedDomainName,
 503     PLSA_FOREST_TRUST_INFORMATION * ForestTrustInfo)
 504 {
 505     FIXME("(%p,%p,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo);
 506     return STATUS_NOT_IMPLEMENTED;
 507 }
 508
 509 /*
 510  * @unimplemented
 511  */
 512 NTSTATUS WINAPI
 513 LsaQueryInformationPolicy(LSA_HANDLE PolicyHandle,
 514               POLICY_INFORMATION_CLASS InformationClass,
 515               PVOID *Buffer)
 516 {
 517     TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 518
 519     if(!Buffer) return STATUS_INVALID_PARAMETER;
 520     switch (InformationClass)
 521     {
 522         case PolicyAuditEventsInformation: /* 2 */
 523         {
 524             PPOLICY_AUDIT_EVENTS_INFO p = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
 525                                                     sizeof(POLICY_AUDIT_EVENTS_INFO));
 526             p->AuditingMode = FALSE; /* no auditing */
 527             *Buffer = p;
 528         }
 529         break;
 530         case PolicyPrimaryDomainInformation: /* 3 */
 531         {
 532             /* Only the domain name is valid for the local computer.
 533              * All other fields are zero.
 534              */
 535             PPOLICY_PRIMARY_DOMAIN_INFO pinfo;
 536
 537             pinfo = ADVAPI_GetDomainName(sizeof(*pinfo), offsetof(POLICY_PRIMARY_DOMAIN_INFO, Name));
 538
 539             TRACE("setting domain to %s\n", debugstr_w(pinfo->Name.Buffer));
 540
 541             *Buffer = pinfo;
 542         }
 543         case PolicyAccountDomainInformation: /* 5 */
 544         {
 545             struct di
 546             {
 547                 POLICY_ACCOUNT_DOMAIN_INFO info;
 548                 SID sid;
 549                 DWORD padding[3];
 550                 WCHAR domain[MAX_COMPUTERNAME_LENGTH + 1];
 551             };
 552             SID_IDENTIFIER_AUTHORITY localSidAuthority = {SECURITY_NT_AUTHORITY};
 553
 554             DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
 555             struct di * xdi = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*xdi));
 556
 557             xdi->info.DomainName.MaximumLength = dwSize * sizeof(WCHAR);
 558             xdi->info.DomainName.Buffer = xdi->domain;
 559             if (GetComputerNameW(xdi->info.DomainName.Buffer, &dwSize))
 560                 xdi->info.DomainName.Length = dwSize * sizeof(WCHAR);
 561
 562             TRACE("setting name to %s\n", debugstr_w(xdi->info.DomainName.Buffer));
 563
 564             xdi->info.DomainSid = &xdi->sid;
 565             xdi->sid.Revision = SID_REVISION;
 566             xdi->sid.SubAuthorityCount = 1;
 567             xdi->sid.IdentifierAuthority = localSidAuthority;
 568             xdi->sid.SubAuthority[0] = SECURITY_LOCAL_SYSTEM_RID;
 569
 570             *Buffer = xdi;
 571         }
 572         break;
 573         case  PolicyDnsDomainInformation:       /* 12 (0xc) */
 574         {
 575             /* Only the domain name is valid for the local computer.
 576              * All other fields are zero.
 577              */
 578             PPOLICY_DNS_DOMAIN_INFO pinfo;
 579
 580             pinfo = ADVAPI_GetDomainName(sizeof(*pinfo), offsetof(POLICY_DNS_DOMAIN_INFO, Name));
 581
 582             TRACE("setting domain to %s\n", debugstr_w(pinfo->Name.Buffer));
 583
 584             *Buffer = pinfo;
 585         }
 586         break;
 587         case PolicyAuditLogInformation:
 588         case PolicyPdAccountInformation:
 589         case PolicyLsaServerRoleInformation:
 590         case PolicyReplicaSourceInformation:
 591         case PolicyDefaultQuotaInformation:
 592         case PolicyModificationInformation:
 593         case PolicyAuditFullSetInformation:
 594         case PolicyAuditFullQueryInformation:
 595         case PolicyEfsInformation:
 596         {
 597             FIXME("category not implemented\n");
 598             return STATUS_UNSUCCESSFUL;
 599         }
 600     }
 601     return STATUS_SUCCESS;
 602 }
 603
 604 /*
 605  * @unimplemented
 606  */
 607 NTSTATUS
 608 WINAPI
 609 LsaQueryTrustedDomainInfoByName(
 610     LSA_HANDLE PolicyHandle,
 611     PLSA_UNICODE_STRING TrustedDomainName,
 612     TRUSTED_INFORMATION_CLASS InformationClass,
 613     PVOID *Buffer)
 614 {
 615     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
 616     return STATUS_NOT_IMPLEMENTED;
 617 }
 618
 619 /*
 620  * @unimplemented
 621  */
 622 NTSTATUS
 623 WINAPI
 624 LsaQueryTrustedDomainInfo(
 625     LSA_HANDLE PolicyHandle,
 626     PSID TrustedDomainSid,
 627     TRUSTED_INFORMATION_CLASS InformationClass,
 628     PVOID *Buffer)
 629 {
 630     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
 631     return STATUS_NOT_IMPLEMENTED;
 632 }
 633
 634 /*
 635  * @unimplemented
 636  */
 637 NTSTATUS
 638 WINAPI
 639 LsaRemoveAccountRights(
 640     LSA_HANDLE PolicyHandle,
 641     PSID AccountSid,
 642     BOOLEAN AllRights,
 643     PLSA_UNICODE_STRING UserRights,
 644     ULONG CountOfRights)
 645 {
 646     FIXME("(%p,%p,%d,%p,0x%08x) stub\n", PolicyHandle, AccountSid, AllRights, UserRights, CountOfRights);
 647     return STATUS_NOT_IMPLEMENTED;
 648 }
 649
 650 /*
 651  * @unimplemented
 652  */
 653 NTSTATUS
 654 WINAPI
 655 LsaRetrievePrivateData(
 656     LSA_HANDLE PolicyHandle,
 657     PLSA_UNICODE_STRING KeyName,
 658     PLSA_UNICODE_STRING *PrivateData)
 659 {
 660     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 661     return STATUS_NOT_IMPLEMENTED;
 662 }
 663
 664 /*
 665  * @unimplemented
 666  */
 667 NTSTATUS
 668 WINAPI
 669 LsaSetDomainInformationPolicy(
 670     LSA_HANDLE PolicyHandle,
 671     POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
 672     PVOID Buffer)
 673 {
 674     FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
 675     return STATUS_NOT_IMPLEMENTED;
 676 }
 677
 678 /*
 679  * @unimplemented
 680  */
 681 NTSTATUS
 682 WINAPI
 683 LsaSetInformationPolicy(
 684     LSA_HANDLE PolicyHandle,
 685     POLICY_INFORMATION_CLASS InformationClass,
 686     PVOID Buffer)
 687 {
 688     FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
 689     return STATUS_NOT_IMPLEMENTED;
 690 }
 691
 692 /*
 693  * @unimplemented
 694  */
 695 NTSTATUS
 696 WINAPI
 697 LsaSetForestTrustInformation(
 698     LSA_HANDLE PolicyHandle,
 699     PLSA_UNICODE_STRING TrustedDomainName,
 700     PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
 701     BOOL CheckOnly,
 702     PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
 703 {
 704     FIXME("(%p,%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo, CheckOnly, CollisionInfo);
 705     return STATUS_NOT_IMPLEMENTED;
 706 }
 707
 708 /*
 709  * @unimplemented
 710  */
 711 NTSTATUS
 712 WINAPI
 713 LsaSetTrustedDomainInfoByName(
 714     LSA_HANDLE PolicyHandle,
 715     PLSA_UNICODE_STRING TrustedDomainName,
 716     TRUSTED_INFORMATION_CLASS InformationClass,
 717     PVOID Buffer)
 718 {
 719     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
 720     return STATUS_NOT_IMPLEMENTED;
 721 }
 722
 723 /*
 724  * @unimplemented
 725  */
 726 NTSTATUS
 727 WINAPI
 728 LsaSetTrustedDomainInformation(
 729     LSA_HANDLE PolicyHandle,
 730     PSID TrustedDomainSid,
 731     TRUSTED_INFORMATION_CLASS InformationClass,
 732     PVOID Buffer)
 733 {
 734     FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
 735     return STATUS_NOT_IMPLEMENTED;
 736 }
 737
 738 /*
 739  * @unimplemented
 740  */
 741 NTSTATUS
 742 WINAPI
 743 LsaStorePrivateData(
 744     LSA_HANDLE PolicyHandle,
 745     PLSA_UNICODE_STRING KeyName,
 746     PLSA_UNICODE_STRING PrivateData)
 747 {
 748     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 749     return STATUS_NOT_IMPLEMENTED;
 750 }
 751
 752 /*
 753  * @unimplemented
 754  */
 755 NTSTATUS
 756 WINAPI
 757 LsaGetUserName(
 758     PUNICODE_STRING *UserName,
 759     PUNICODE_STRING *DomainName)
 760 {
 761     FIXME("(%p,%p) stub\n", UserName, DomainName);
 762     return STATUS_NOT_IMPLEMENTED;
 763 }
 764
 765 /*
 766  * @unimplemented
 767  */
 768 NTSTATUS
 769 WINAPI
 770 LsaQueryInfoTrustedDomain (DWORD Unknonw0,
 771                            DWORD Unknonw1,
 772                            DWORD Unknonw2)
 773 {
 774     FIXME("(%d,%d,%d) stub\n", Unknonw0, Unknonw1, Unknonw2);
 775     return STATUS_NOT_IMPLEMENTED;
 776 }
 777
 778
 779 /* EOF */