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