reactos/dll/win32/lsasrv/lsarpc.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         Local Security Authority (LSA) Server
   4  * FILE:            reactos/dll/win32/lsasrv/lsarpc.h
   5  * PURPOSE:         RPC interface functions
   6  *
   7  * PROGRAMMERS:     Eric Kohl
   8  */
   9
  10 /* INCLUDES ****************************************************************/
  11
  12 #include "lsasrv.h"
  13
  14
  15 static RTL_CRITICAL_SECTION PolicyHandleTableLock;
  16
  17 WINE_DEFAULT_DEBUG_CHANNEL(lsasrv);
  18
  19
  20 /* FUNCTIONS ***************************************************************/
  21
  22
  23 VOID
  24 LsarStartRpcServer(VOID)
  25 {
  26     RPC_STATUS Status;
  27
  28     RtlInitializeCriticalSection(&PolicyHandleTableLock);
  29
  30     TRACE("LsarStartRpcServer() called\n");
  31
  32     Status = RpcServerUseProtseqEpW(L"ncacn_np",
  33                                     10,
  34                                     L"\\pipe\\lsarpc",
  35                                     NULL);
  36     if (Status != RPC_S_OK)
  37     {
  38         WARN("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
  39         return;
  40     }
  41
  42     Status = RpcServerRegisterIf(lsarpc_v0_0_s_ifspec,
  43                                  NULL,
  44                                  NULL);
  45     if (Status != RPC_S_OK)
  46     {
  47         WARN("RpcServerRegisterIf() failed (Status %lx)\n", Status);
  48         return;
  49     }
  50
  51     Status = RpcServerListen(1, 20, TRUE);
  52     if (Status != RPC_S_OK)
  53     {
  54         WARN("RpcServerListen() failed (Status %lx)\n", Status);
  55         return;
  56     }
  57
  58     TRACE("LsarStartRpcServer() done\n");
  59 }
  60
  61
  62 void __RPC_USER LSAPR_HANDLE_rundown(LSAPR_HANDLE hHandle)
  63 {
  64
  65 }
  66
  67
  68 /* Function 0 */
  69 NTSTATUS WINAPI LsarClose(
  70     LSAPR_HANDLE *ObjectHandle)
  71 {
  72     NTSTATUS Status = STATUS_SUCCESS;
  73
  74     TRACE("0x%p\n", ObjectHandle);
  75
  76 //    RtlEnterCriticalSection(&PolicyHandleTableLock);
  77
  78     Status = LsapValidateDbObject(*ObjectHandle,
  79                                   LsaDbIgnoreObject,
  80                                   0);
  81     if (Status == STATUS_SUCCESS)
  82     {
  83         Status = LsapCloseDbObject(*ObjectHandle);
  84         *ObjectHandle = NULL;
  85     }
  86
  87 //    RtlLeaveCriticalSection(&PolicyHandleTableLock);
  88
  89     return Status;
  90 }
  91
  92
  93 /* Function 1 */
  94 NTSTATUS WINAPI LsarDelete(
  95     LSAPR_HANDLE ObjectHandle)
  96 {
  97     /* Deprecated */
  98     return STATUS_NOT_SUPPORTED;
  99 }
 100
 101
 102 /* Function 2 */
 103 NTSTATUS WINAPI LsarEnumeratePrivileges(
 104     LSAPR_HANDLE PolicyHandle,
 105     DWORD *EnumerationContext,
 106     PLSAPR_PRIVILEGE_ENUM_BUFFER EnumerationBuffer,
 107     DWORD PreferedMaximumLength)
 108 {
 109     UNIMPLEMENTED;
 110     return STATUS_NOT_IMPLEMENTED;
 111 }
 112
 113
 114 /* Function 3 */
 115 NTSTATUS WINAPI LsarQuerySecurityObject(
 116     LSAPR_HANDLE ObjectHandle,
 117     SECURITY_INFORMATION SecurityInformation,
 118     PLSAPR_SR_SECURITY_DESCRIPTOR *SecurityDescriptor)
 119 {
 120     UNIMPLEMENTED;
 121     return STATUS_NOT_IMPLEMENTED;
 122 }
 123
 124
 125 /* Function 4 */
 126 NTSTATUS WINAPI LsarSetSecurityObject(
 127     LSAPR_HANDLE ObjectHandle,
 128     SECURITY_INFORMATION SecurityInformation,
 129     PLSAPR_SR_SECURITY_DESCRIPTOR SecurityDescriptor)
 130 {
 131     UNIMPLEMENTED;
 132     return STATUS_NOT_IMPLEMENTED;
 133 }
 134
 135
 136 /* Function 5 */
 137 NTSTATUS WINAPI LsarChangePassword(
 138     handle_t IDL_handle,
 139     PRPC_UNICODE_STRING String1,
 140     PRPC_UNICODE_STRING String2,
 141     PRPC_UNICODE_STRING String3,
 142     PRPC_UNICODE_STRING String4,
 143     PRPC_UNICODE_STRING String5)
 144 {
 145     /* Deprecated */
 146     return STATUS_NOT_IMPLEMENTED;
 147 }
 148
 149
 150 /* Function 6 */
 151 NTSTATUS WINAPI LsarOpenPolicy(
 152     LPWSTR SystemName,
 153     PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,
 154     ACCESS_MASK DesiredAccess,
 155     LSAPR_HANDLE *PolicyHandle)
 156 {
 157     NTSTATUS Status = STATUS_SUCCESS;
 158
 159     TRACE("LsarOpenPolicy called!\n");
 160
 161     RtlEnterCriticalSection(&PolicyHandleTableLock);
 162
 163     *PolicyHandle = LsapCreateDbObject(NULL,
 164                                        L"Policy",
 165                                        TRUE,
 166                                        LsaDbPolicyObject,
 167                                        DesiredAccess);
 168     if (*PolicyHandle == NULL)
 169         Status = STATUS_INSUFFICIENT_RESOURCES;
 170
 171     RtlLeaveCriticalSection(&PolicyHandleTableLock);
 172
 173     TRACE("LsarOpenPolicy done!\n");
 174
 175     return Status;
 176 }
 177
 178
 179 /* Function 7 */
 180 NTSTATUS WINAPI LsarQueryInformationPolicy(
 181     LSAPR_HANDLE PolicyHandle,
 182     POLICY_INFORMATION_CLASS InformationClass,
 183     PLSAPR_POLICY_INFORMATION *PolicyInformation)
 184 {
 185     NTSTATUS Status;
 186
 187     TRACE("LsarQueryInformationPolicy(%p,0x%08x,%p)\n",
 188           PolicyHandle, InformationClass, PolicyInformation);
 189
 190     if (PolicyInformation)
 191     {
 192         TRACE("*PolicyInformation %p\n", *PolicyInformation);
 193     }
 194
 195     Status = LsapValidateDbObject(PolicyHandle,
 196                                   LsaDbPolicyObject,
 197                                   0); /* FIXME */
 198     if (!NT_SUCCESS(Status))
 199         return Status;
 200
 201     switch (InformationClass)
 202     {
 203         case PolicyAuditEventsInformation:   /* 2 */
 204             Status = LsarQueryAuditEvents(PolicyHandle,
 205                                           PolicyInformation);
 206             break;
 207
 208         case PolicyPrimaryDomainInformation: /* 3 */
 209             Status = LsarQueryPrimaryDomain(PolicyHandle,
 210                                             PolicyInformation);
 211             break;
 212
 213         case PolicyAccountDomainInformation: /* 5 */
 214             Status = LsarQueryAccountDomain(PolicyHandle,
 215                                             PolicyInformation);
 216             break;
 217
 218         case PolicyDnsDomainInformation:     /* 12 (0xc) */
 219             Status = LsarQueryDnsDomain(PolicyHandle,
 220                                         PolicyInformation);
 221             break;
 222
 223         case PolicyAuditLogInformation:
 224         case PolicyPdAccountInformation:
 225         case PolicyLsaServerRoleInformation:
 226         case PolicyReplicaSourceInformation:
 227         case PolicyDefaultQuotaInformation:
 228         case PolicyModificationInformation:
 229         case PolicyAuditFullSetInformation:
 230         case PolicyAuditFullQueryInformation:
 231         case PolicyEfsInformation:
 232             FIXME("category not implemented\n");
 233             Status = STATUS_UNSUCCESSFUL;
 234             break;
 235     }
 236
 237     return Status;
 238 }
 239
 240
 241 /* Function 8 */
 242 NTSTATUS WINAPI LsarSetInformationPolicy(
 243     LSAPR_HANDLE PolicyHandle,
 244     POLICY_INFORMATION_CLASS InformationClass,
 245     PLSAPR_POLICY_INFORMATION PolicyInformation)
 246 {
 247     NTSTATUS Status;
 248
 249     TRACE("LsarSetInformationPolicy(%p,0x%08x,%p)\n",
 250           PolicyHandle, InformationClass, PolicyInformation);
 251
 252     if (PolicyInformation)
 253     {
 254         TRACE("*PolicyInformation %p\n", *PolicyInformation);
 255     }
 256
 257     Status = LsapValidateDbObject(PolicyHandle,
 258                                   LsaDbPolicyObject,
 259                                   0); /* FIXME */
 260     if (!NT_SUCCESS(Status))
 261         return Status;
 262
 263     switch (InformationClass)
 264     {
 265         case PolicyAuditEventsInformation:
 266             Status = STATUS_NOT_IMPLEMENTED;
 267             break;
 268
 269         case PolicyPrimaryDomainInformation:
 270             Status = LsarSetPrimaryDomain(PolicyHandle,
 271                                           (PLSAPR_POLICY_PRIMARY_DOM_INFO)PolicyInformation);
 272             break;
 273
 274         case PolicyAccountDomainInformation:
 275             Status = LsarSetAccountDomain(PolicyHandle,
 276                                           (PLSAPR_POLICY_ACCOUNT_DOM_INFO)PolicyInformation);
 277             break;
 278
 279         case PolicyDnsDomainInformation:
 280             Status = LsarSetDnsDomain(PolicyHandle,
 281                                       (PLSAPR_POLICY_DNS_DOMAIN_INFO)PolicyInformation);
 282             break;
 283
 284         case PolicyLsaServerRoleInformation:
 285             Status = STATUS_NOT_IMPLEMENTED;
 286             break;
 287
 288         default:
 289             Status = STATUS_INVALID_PARAMETER;
 290             break;
 291     }
 292
 293     return Status;
 294 }
 295
 296
 297 /* Function 9 */
 298 NTSTATUS WINAPI LsarClearAuditLog(
 299     LSAPR_HANDLE ObjectHandle)
 300 {
 301     /* Deprecated */
 302     return STATUS_NOT_IMPLEMENTED;
 303 }
 304
 305
 306 /* Function 10 */
 307 NTSTATUS WINAPI LsarCreateAccount(
 308     LSAPR_HANDLE PolicyHandle,
 309     PRPC_SID AccountSid,
 310     ACCESS_MASK DesiredAccess,
 311     LSAPR_HANDLE *AccountHandle)
 312 {
 313     LSAPR_HANDLE AccountsHandle;
 314     LSAPR_HANDLE Account;
 315     LPWSTR SidString;
 316     NTSTATUS Status;
 317
 318     /* Validate the PolicyHandle */
 319     Status = LsapValidateDbObject(PolicyHandle,
 320                                   LsaDbPolicyObject,
 321                                   POLICY_CREATE_ACCOUNT);
 322     if (!NT_SUCCESS(Status))
 323     {
 324         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
 325         return Status;
 326     }
 327
 328     /* Open the Accounts object */
 329     AccountsHandle = LsapCreateDbObject(PolicyHandle,
 330                                         L"Accounts",
 331                                         TRUE,
 332                                         LsaDbContainerObject,
 333                                         0);
 334     if (AccountsHandle == NULL)
 335     {
 336         ERR("LsapCreateDbObject (Accounts) failed\n");
 337         return STATUS_UNSUCCESSFUL;
 338     }
 339
 340     /* Create SID string */
 341     if (!ConvertSidToStringSid((PSID)AccountSid,
 342                                &SidString))
 343     {
 344         ERR("ConvertSidToStringSid failed\n");
 345         return STATUS_UNSUCCESSFUL;
 346     }
 347
 348     /* Create the Account object */
 349     Account = LsapCreateDbObject(AccountsHandle,
 350                                  SidString,
 351                                  FALSE,
 352                                  LsaDbAccountObject,
 353                                  DesiredAccess);
 354     if (Account != NULL)
 355     {
 356         /* Set the Sid attribute */
 357         Status = LsapSetObjectAttribute((PLSA_DB_OBJECT)Account,
 358                                         L"Sid",
 359                                         (PVOID)AccountSid,
 360                                         GetLengthSid(AccountSid));
 361         if (NT_SUCCESS(Status))
 362         {
 363             *AccountHandle = Account;
 364         }
 365     }
 366
 367     LocalFree(SidString);
 368
 369     LsapCloseDbObject(AccountsHandle);
 370
 371     return STATUS_SUCCESS;
 372 }
 373
 374
 375 /* Function 11 */
 376 NTSTATUS WINAPI LsarEnumerateAccounts(
 377     LSAPR_HANDLE PolicyHandle,
 378     DWORD *EnumerationContext,
 379     PLSAPR_ACCOUNT_ENUM_BUFFER EnumerationBuffer,
 380     DWORD PreferedMaximumLength)
 381 {
 382     UNIMPLEMENTED;
 383     return STATUS_NOT_IMPLEMENTED;
 384 }
 385
 386
 387 /* Function 12 */
 388 NTSTATUS WINAPI LsarCreateTrustedDomain(
 389     LSAPR_HANDLE PolicyHandle,
 390     PLSAPR_TRUST_INFORMATION TrustedDomainInformation,
 391     ACCESS_MASK DesiredAccess,
 392     LSAPR_HANDLE *TrustedDomainHandle)
 393 {
 394     UNIMPLEMENTED;
 395     return STATUS_NOT_IMPLEMENTED;
 396 }
 397
 398
 399 /* Function 13 */
 400 NTSTATUS WINAPI LsarEnumerateTrustedDomains(
 401     LSAPR_HANDLE PolicyHandle,
 402     DWORD *EnumerationContext,
 403     PLSAPR_TRUSTED_ENUM_BUFFER EnumerationBuffer,
 404     DWORD PreferedMaximumLength)
 405 {
 406     UNIMPLEMENTED;
 407     return STATUS_NOT_IMPLEMENTED;
 408 }
 409
 410
 411 /* Function 14 */
 412 NTSTATUS WINAPI LsarLookupNames(
 413     LSAPR_HANDLE PolicyHandle,
 414     DWORD Count,
 415     PRPC_UNICODE_STRING Names,
 416     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 417     PLSAPR_TRANSLATED_SIDS TranslatedSids,
 418     LSAP_LOOKUP_LEVEL LookupLevel,
 419     DWORD *MappedCount)
 420 {
 421     SID_IDENTIFIER_AUTHORITY IdentifierAuthority = {SECURITY_NT_AUTHORITY};
 422     static const UNICODE_STRING DomainName = RTL_CONSTANT_STRING(L"DOMAIN");
 423     PLSAPR_REFERENCED_DOMAIN_LIST OutputDomains = NULL;
 424     PLSA_TRANSLATED_SID OutputSids = NULL;
 425     ULONG OutputSidsLength;
 426     ULONG i;
 427     PSID Sid;
 428     ULONG SidLength;
 429     NTSTATUS Status;
 430
 431     TRACE("LsarLookupNames(%p, %lu, %p, %p, %p, %d, %p)\n",
 432           PolicyHandle, Count, Names, ReferencedDomains, TranslatedSids,
 433           LookupLevel, MappedCount);
 434
 435     TranslatedSids->Entries = Count;
 436     TranslatedSids->Sids = NULL;
 437     *ReferencedDomains = NULL;
 438
 439     OutputSidsLength = Count * sizeof(LSA_TRANSLATED_SID);
 440     OutputSids = MIDL_user_allocate(OutputSidsLength);
 441     if (OutputSids == NULL)
 442     {
 443         return STATUS_INSUFFICIENT_RESOURCES;
 444     }
 445
 446     RtlZeroMemory(OutputSids, OutputSidsLength);
 447
 448     OutputDomains = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
 449     if (OutputDomains == NULL)
 450     {
 451         MIDL_user_free(OutputSids);
 452         return STATUS_INSUFFICIENT_RESOURCES;
 453     }
 454
 455     OutputDomains->Entries = Count;
 456     OutputDomains->Domains = MIDL_user_allocate(Count * sizeof(LSA_TRUST_INFORMATION));
 457     if (OutputDomains->Domains == NULL)
 458     {
 459         MIDL_user_free(OutputDomains);
 460         MIDL_user_free(OutputSids);
 461         return STATUS_INSUFFICIENT_RESOURCES;
 462     }
 463
 464     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
 465                                          2,
 466                                          SECURITY_BUILTIN_DOMAIN_RID,
 467                                          DOMAIN_ALIAS_RID_ADMINS,
 468                                          0, 0, 0, 0, 0, 0,
 469                                          &Sid);
 470     if (!NT_SUCCESS(Status))
 471     {
 472         MIDL_user_free(OutputDomains->Domains);
 473         MIDL_user_free(OutputDomains);
 474         MIDL_user_free(OutputSids);
 475         return Status;
 476     }
 477
 478     SidLength = RtlLengthSid(Sid);
 479
 480     for (i = 0; i < Count; i++)
 481     {
 482         OutputDomains->Domains[i].Sid = MIDL_user_allocate(SidLength);
 483         RtlCopyMemory(OutputDomains->Domains[i].Sid, Sid, SidLength);
 484
 485         OutputDomains->Domains[i].Name.Buffer = MIDL_user_allocate(DomainName.MaximumLength);
 486         OutputDomains->Domains[i].Name.Length = DomainName.Length;
 487         OutputDomains->Domains[i].Name.MaximumLength = DomainName.MaximumLength;
 488         RtlCopyMemory(OutputDomains->Domains[i].Name.Buffer, DomainName.Buffer, DomainName.MaximumLength);
 489     }
 490
 491     for (i = 0; i < Count; i++)
 492     {
 493         OutputSids[i].Use = SidTypeWellKnownGroup;
 494         OutputSids[i].RelativeId = DOMAIN_USER_RID_ADMIN; //DOMAIN_ALIAS_RID_ADMINS;
 495         OutputSids[i].DomainIndex = i;
 496     }
 497
 498     *ReferencedDomains = OutputDomains;
 499
 500     *MappedCount = Count;
 501
 502     TranslatedSids->Entries = Count;
 503     TranslatedSids->Sids = OutputSids;
 504
 505     return STATUS_SUCCESS;
 506 }
 507
 508
 509 /* Function 15 */
 510 NTSTATUS WINAPI LsarLookupSids(
 511     LSAPR_HANDLE PolicyHandle,
 512     PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
 513     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 514     PLSAPR_TRANSLATED_NAMES TranslatedNames,
 515     LSAP_LOOKUP_LEVEL LookupLevel,
 516     DWORD *MappedCount)
 517 {
 518     SID_IDENTIFIER_AUTHORITY IdentifierAuthority = {SECURITY_NT_AUTHORITY};
 519     static const UNICODE_STRING DomainName = RTL_CONSTANT_STRING(L"DOMAIN");
 520     PLSAPR_REFERENCED_DOMAIN_LIST OutputDomains = NULL;
 521     PLSAPR_TRANSLATED_NAME OutputNames = NULL;
 522     ULONG OutputNamesLength;
 523     ULONG i;
 524     PSID Sid;
 525     ULONG SidLength;
 526     NTSTATUS Status;
 527
 528     TRACE("LsarLookupSids(%p, %p, %p, %p, %d, %p)\n",
 529           PolicyHandle, SidEnumBuffer, ReferencedDomains, TranslatedNames,
 530           LookupLevel, MappedCount);
 531
 532     TranslatedNames->Entries = SidEnumBuffer->Entries;
 533     TranslatedNames->Names = NULL;
 534     *ReferencedDomains = NULL;
 535
 536     OutputNamesLength = SidEnumBuffer->Entries * sizeof(LSA_TRANSLATED_NAME);
 537     OutputNames = MIDL_user_allocate(OutputNamesLength);
 538     if (OutputNames == NULL)
 539     {
 540         return STATUS_INSUFFICIENT_RESOURCES;
 541     }
 542
 543     RtlZeroMemory(OutputNames, OutputNamesLength);
 544
 545     OutputDomains = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
 546     if (OutputDomains == NULL)
 547     {
 548         MIDL_user_free(OutputNames);
 549         return STATUS_INSUFFICIENT_RESOURCES;
 550     }
 551
 552     OutputDomains->Entries = SidEnumBuffer->Entries;
 553     OutputDomains->Domains = MIDL_user_allocate(SidEnumBuffer->Entries * sizeof(LSA_TRUST_INFORMATION));
 554     if (OutputDomains->Domains == NULL)
 555     {
 556         MIDL_user_free(OutputDomains);
 557         MIDL_user_free(OutputNames);
 558         return STATUS_INSUFFICIENT_RESOURCES;
 559     }
 560
 561     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
 562                                          2,
 563                                          SECURITY_BUILTIN_DOMAIN_RID,
 564                                          DOMAIN_ALIAS_RID_ADMINS,
 565                                          0, 0, 0, 0, 0, 0,
 566                                          &Sid);
 567     if (!NT_SUCCESS(Status))
 568     {
 569         MIDL_user_free(OutputDomains->Domains);
 570         MIDL_user_free(OutputDomains);
 571         MIDL_user_free(OutputNames);
 572         return Status;
 573     }
 574
 575     SidLength = RtlLengthSid(Sid);
 576
 577     for (i = 0; i < SidEnumBuffer->Entries; i++)
 578     {
 579         OutputDomains->Domains[i].Sid = MIDL_user_allocate(SidLength);
 580         RtlCopyMemory(OutputDomains->Domains[i].Sid, Sid, SidLength);
 581
 582         OutputDomains->Domains[i].Name.Buffer = MIDL_user_allocate(DomainName.MaximumLength);
 583         OutputDomains->Domains[i].Name.Length = DomainName.Length;
 584         OutputDomains->Domains[i].Name.MaximumLength = DomainName.MaximumLength;
 585         RtlCopyMemory(OutputDomains->Domains[i].Name.Buffer, DomainName.Buffer, DomainName.MaximumLength);
 586     }
 587
 588     Status = LsapLookupSids(SidEnumBuffer,
 589                             OutputNames);
 590
 591     *ReferencedDomains = OutputDomains;
 592
 593     *MappedCount = SidEnumBuffer->Entries;
 594
 595     TranslatedNames->Entries = SidEnumBuffer->Entries;
 596     TranslatedNames->Names = OutputNames;
 597
 598     return Status;
 599 }
 600
 601
 602 /* Function 16 */
 603 NTSTATUS WINAPI LsarCreateSecret(
 604     LSAPR_HANDLE PolicyHandle,
 605     PRPC_UNICODE_STRING SecretName,
 606     ACCESS_MASK DesiredAccess,
 607     LSAPR_HANDLE *SecretHandle)
 608 {
 609     UNIMPLEMENTED;
 610     return STATUS_NOT_IMPLEMENTED;
 611 }
 612
 613
 614 /* Function 17 */
 615 NTSTATUS WINAPI LsarOpenAccount(
 616     LSAPR_HANDLE PolicyHandle,
 617     PRPC_SID AccountSid,
 618     ACCESS_MASK DesiredAccess,
 619     LSAPR_HANDLE *AccountHandle)
 620 {
 621     UNIMPLEMENTED;
 622     return STATUS_NOT_IMPLEMENTED;
 623 }
 624
 625
 626 /* Function 18 */
 627 NTSTATUS WINAPI LsarEnumeratePrivilegesAccount(
 628     LSAPR_HANDLE AccountHandle,
 629     PLSAPR_PRIVILEGE_SET *Privileges)
 630 {
 631     UNIMPLEMENTED;
 632     return STATUS_NOT_IMPLEMENTED;
 633 }
 634
 635
 636 /* Function 19 */
 637 NTSTATUS WINAPI LsarAddPrivilegesToAccount(
 638     LSAPR_HANDLE AccountHandle,
 639     PLSAPR_PRIVILEGE_SET Privileges)
 640 {
 641     UNIMPLEMENTED;
 642     return STATUS_NOT_IMPLEMENTED;
 643 }
 644
 645
 646 /* Function 20 */
 647 NTSTATUS WINAPI LsarRemovePrivilegesFromAccount(
 648     LSAPR_HANDLE AccountHandle,
 649     BOOL AllPrivileges,
 650     PLSAPR_PRIVILEGE_SET Privileges)
 651 {
 652     UNIMPLEMENTED;
 653     return STATUS_NOT_IMPLEMENTED;
 654 }
 655
 656
 657 /* Function 21 */
 658 NTSTATUS WINAPI LsarGetQuotasForAccount(
 659     LSAPR_HANDLE AccountHandle,
 660     PQUOTA_LIMITS QuotaLimits)
 661 {
 662     UNIMPLEMENTED;
 663     return STATUS_NOT_IMPLEMENTED;
 664 }
 665
 666
 667 /* Function 22 */
 668 NTSTATUS WINAPI LsarSetQuotasForAccount(
 669     LSAPR_HANDLE AccountHandle,
 670     PQUOTA_LIMITS QuotaLimits)
 671 {
 672     UNIMPLEMENTED;
 673     return STATUS_NOT_IMPLEMENTED;
 674 }
 675
 676
 677 /* Function 23 */
 678 NTSTATUS WINAPI LsarGetSystemAccessAccount(
 679     LSAPR_HANDLE AccountHandle,
 680     ACCESS_MASK *SystemAccess)
 681 {
 682     UNIMPLEMENTED;
 683     return STATUS_NOT_IMPLEMENTED;
 684 }
 685
 686
 687 /* Function 24 */
 688 NTSTATUS WINAPI LsarSetSystemAccessAccount(
 689     LSAPR_HANDLE AccountHandle,
 690     ACCESS_MASK SystemAccess)
 691 {
 692     UNIMPLEMENTED;
 693     return STATUS_NOT_IMPLEMENTED;
 694 }
 695
 696
 697 /* Function 25 */
 698 NTSTATUS WINAPI LsarOpenTrustedDomain(
 699     LSAPR_HANDLE PolicyHandle,
 700     PRPC_SID TrustedDomainSid,
 701     ACCESS_MASK DesiredAccess,
 702     LSAPR_HANDLE *TrustedDomainHandle)
 703 {
 704     UNIMPLEMENTED;
 705     return STATUS_NOT_IMPLEMENTED;
 706 }
 707
 708
 709 /* Function 26 */
 710 NTSTATUS WINAPI LsarQueryInfoTrustedDomain(
 711     LSAPR_HANDLE TrustedDomainHandle,
 712     TRUSTED_INFORMATION_CLASS InformationClass,
 713     PLSAPR_TRUSTED_DOMAIN_INFO *TrustedDomainInformation)
 714 {
 715     UNIMPLEMENTED;
 716     return STATUS_NOT_IMPLEMENTED;
 717 }
 718
 719
 720 /* Function 27 */
 721 NTSTATUS WINAPI LsarSetInformationTrustedDomain(
 722     LSAPR_HANDLE TrustedDomainHandle,
 723     TRUSTED_INFORMATION_CLASS InformationClass,
 724     PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation)
 725 {
 726     UNIMPLEMENTED;
 727     return STATUS_NOT_IMPLEMENTED;
 728 }
 729
 730
 731 /* Function 28 */
 732 NTSTATUS WINAPI LsarOpenSecret(
 733     LSAPR_HANDLE PolicyHandle,
 734     PRPC_UNICODE_STRING SecretName,
 735     ACCESS_MASK DesiredAccess,
 736     LSAPR_HANDLE *SecretHandle)
 737 {
 738     UNIMPLEMENTED;
 739     return STATUS_NOT_IMPLEMENTED;
 740 }
 741
 742
 743 /* Function 29 */
 744 NTSTATUS WINAPI LsarSetSecret(
 745     LSAPR_HANDLE *SecretHandle,
 746     PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue,
 747     PLSAPR_CR_CIPHER_VALUE EncryptedOldValue)
 748 {
 749     UNIMPLEMENTED;
 750     return STATUS_NOT_IMPLEMENTED;
 751 }
 752
 753
 754 /* Function 30 */
 755 NTSTATUS WINAPI LsarQuerySecret(
 756     LSAPR_HANDLE SecretHandle,
 757     PLSAPR_CR_CIPHER_VALUE *EncryptedCurrentValue,
 758     PLARGE_INTEGER CurrentValueSetTime,
 759     PLSAPR_CR_CIPHER_VALUE *EncryptedOldValue,
 760     PLARGE_INTEGER OldValueSetTime)
 761 {
 762     UNIMPLEMENTED;
 763     return STATUS_NOT_IMPLEMENTED;
 764 }
 765
 766
 767 /* Function 31 */
 768 NTSTATUS WINAPI LsarLookupPrivilegeValue(
 769     LSAPR_HANDLE PolicyHandle,
 770     PRPC_UNICODE_STRING Name,
 771     PLUID Value)
 772 {
 773     NTSTATUS Status;
 774
 775     TRACE("LsarLookupPrivilegeValue(%p, %wZ, %p)\n",
 776           PolicyHandle, Name, Value);
 777
 778     Status = LsapValidateDbObject(PolicyHandle,
 779                                   LsaDbPolicyObject,
 780                                   0); /* FIXME */
 781     if (!NT_SUCCESS(Status))
 782     {
 783         ERR("Invalid handle (Status %lx)\n", Status);
 784         return Status;
 785     }
 786
 787     TRACE("Privilege: %wZ\n", Name);
 788
 789     Status = LsarpLookupPrivilegeValue((PUNICODE_STRING)Name,
 790                                        Value);
 791
 792     return Status;
 793 }
 794
 795
 796 /* Function 32 */
 797 NTSTATUS WINAPI LsarLookupPrivilegeName(
 798     LSAPR_HANDLE PolicyHandle,
 799     PLUID Value,
 800     PRPC_UNICODE_STRING *Name)
 801 {
 802     NTSTATUS Status;
 803
 804     TRACE("LsarLookupPrivilegeName(%p, %p, %p)\n",
 805           PolicyHandle, Value, Name);
 806
 807     Status = LsapValidateDbObject(PolicyHandle,
 808                                   LsaDbPolicyObject,
 809                                   0); /* FIXME */
 810     if (!NT_SUCCESS(Status))
 811     {
 812         ERR("Invalid handle\n");
 813         return Status;
 814     }
 815
 816     Status = LsarpLookupPrivilegeName(Value, (PUNICODE_STRING*)Name);
 817
 818     return Status;
 819 }
 820
 821
 822 /* Function 33 */
 823 NTSTATUS WINAPI LsarLookupPrivilegeDisplayName(
 824     LSAPR_HANDLE PolicyHandle,
 825     PRPC_UNICODE_STRING Name,
 826     USHORT ClientLanguage,
 827     USHORT ClientSystemDefaultLanguage,
 828     PRPC_UNICODE_STRING *DisplayName,
 829     USHORT *LanguageReturned)
 830 {
 831     UNIMPLEMENTED;
 832     return STATUS_NOT_IMPLEMENTED;
 833 }
 834
 835
 836 /* Function 34 */
 837 NTSTATUS WINAPI LsarDeleteObject(
 838     LSAPR_HANDLE *ObjectHandle)
 839 {
 840     UNIMPLEMENTED;
 841     return STATUS_NOT_IMPLEMENTED;
 842 }
 843
 844
 845 /* Function 35 */
 846 NTSTATUS WINAPI LsarEnumerateAccountsWithUserRight(
 847     LSAPR_HANDLE PolicyHandle,
 848     PRPC_UNICODE_STRING UserRight,
 849     PLSAPR_ACCOUNT_ENUM_BUFFER EnumerationBuffer)
 850 {
 851     UNIMPLEMENTED;
 852     return STATUS_NOT_IMPLEMENTED;
 853 }
 854
 855
 856 /* Function 36 */
 857 NTSTATUS WINAPI LsarEnmuerateAccountRights(
 858     LSAPR_HANDLE PolicyHandle,
 859     PRPC_SID AccountSid,
 860     PLSAPR_USER_RIGHT_SET UserRights)
 861 {
 862     NTSTATUS Status;
 863
 864     FIXME("(%p,%p,%p) stub\n", PolicyHandle, AccountSid, UserRights);
 865
 866     Status = LsapValidateDbObject(PolicyHandle,
 867                                   LsaDbPolicyObject,
 868                                   0); /* FIXME */
 869     if (!NT_SUCCESS(Status))
 870         return Status;
 871
 872     UserRights->Entries = 0;
 873     UserRights->UserRights = NULL;
 874     return STATUS_OBJECT_NAME_NOT_FOUND;
 875 }
 876
 877
 878 /* Function 37 */
 879 NTSTATUS WINAPI LsarAddAccountRights(
 880     LSAPR_HANDLE PolicyHandle,
 881     PRPC_SID AccountSid,
 882     PLSAPR_USER_RIGHT_SET UserRights)
 883 {
 884     UNIMPLEMENTED;
 885     return STATUS_NOT_IMPLEMENTED;
 886 }
 887
 888
 889 /* Function 38 */
 890 NTSTATUS WINAPI LsarRemoveAccountRights(
 891     LSAPR_HANDLE PolicyHandle,
 892     PRPC_SID AccountSid,
 893     BOOL AllRights,
 894     PLSAPR_USER_RIGHT_SET UserRights)
 895 {
 896     UNIMPLEMENTED;
 897     return STATUS_NOT_IMPLEMENTED;
 898 }
 899
 900
 901 /* Function 39 */
 902 NTSTATUS WINAPI LsarQueryTrustedDomainInfo(
 903     LSAPR_HANDLE PolicyHandle,
 904     PRPC_SID TrustedDomainSid,
 905     TRUSTED_INFORMATION_CLASS InformationClass,
 906     PLSAPR_TRUSTED_DOMAIN_INFO *TrustedDomainInformation)
 907 {
 908     UNIMPLEMENTED;
 909     return STATUS_NOT_IMPLEMENTED;
 910 }
 911
 912
 913 /* Function 40 */
 914 NTSTATUS WINAPI LsarSetTrustedDomainInfo(
 915     LSAPR_HANDLE PolicyHandle,
 916     PRPC_SID TrustedDomainSid,
 917     TRUSTED_INFORMATION_CLASS InformationClass,
 918     PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation)
 919 {
 920     UNIMPLEMENTED;
 921     return STATUS_NOT_IMPLEMENTED;
 922 }
 923
 924
 925 /* Function 41 */
 926 NTSTATUS WINAPI LsarDeleteTrustedDomain(
 927     LSAPR_HANDLE PolicyHandle,
 928     PRPC_SID TrustedDomainSid)
 929 {
 930     UNIMPLEMENTED;
 931     return STATUS_NOT_IMPLEMENTED;
 932 }
 933
 934
 935 /* Function 42 */
 936 NTSTATUS WINAPI LsarStorePrivateData(
 937     LSAPR_HANDLE PolicyHandle,
 938     PRPC_UNICODE_STRING KeyName,
 939     PLSAPR_CR_CIPHER_VALUE EncryptedData)
 940 {
 941     UNIMPLEMENTED;
 942     return STATUS_NOT_IMPLEMENTED;
 943 }
 944
 945
 946 /* Function 43 */
 947 NTSTATUS WINAPI LsarRetrievePrivateData(
 948     LSAPR_HANDLE PolicyHandle,
 949     PRPC_UNICODE_STRING KeyName,
 950     PLSAPR_CR_CIPHER_VALUE *EncryptedData)
 951 {
 952     UNIMPLEMENTED;
 953     return STATUS_NOT_IMPLEMENTED;
 954 }
 955
 956
 957 /* Function 44 */
 958 NTSTATUS WINAPI LsarOpenPolicy2(
 959     LPWSTR SystemName,
 960     PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,
 961     ACCESS_MASK DesiredAccess,
 962     LSAPR_HANDLE *PolicyHandle)
 963 {
 964     UNIMPLEMENTED;
 965     return STATUS_NOT_IMPLEMENTED;
 966 }
 967
 968
 969 /* Function 45 */
 970 NTSTATUS WINAPI LsarGetUserName(
 971     LPWSTR SystemName,
 972     PRPC_UNICODE_STRING *UserName,
 973     PRPC_UNICODE_STRING *DomainName)
 974 {
 975     UNIMPLEMENTED;
 976     return STATUS_NOT_IMPLEMENTED;
 977 }
 978
 979
 980 /* Function 46 */
 981 NTSTATUS WINAPI LsarQueryInformationPolicy2(
 982     LSAPR_HANDLE PolicyHandle,
 983     POLICY_INFORMATION_CLASS InformationClass,
 984     unsigned long *PolicyInformation)
 985 {
 986     UNIMPLEMENTED;
 987     return STATUS_NOT_IMPLEMENTED;
 988 }
 989
 990
 991 /* Function 47 */
 992 NTSTATUS WINAPI LsarSetInformationPolicy2(
 993     LSAPR_HANDLE PolicyHandle,
 994     POLICY_INFORMATION_CLASS InformationClass,
 995     unsigned long PolicyInformation)
 996 {
 997     UNIMPLEMENTED;
 998     return STATUS_NOT_IMPLEMENTED;
 999 }
1000
1001
1002 /* Function 48 */
1003 NTSTATUS WINAPI LsarQueryTrustedDomainInfoByName(
1004     LSAPR_HANDLE PolicyHandle,
1005     PRPC_UNICODE_STRING TrustedDomainName,
1006     POLICY_INFORMATION_CLASS InformationClass,
1007     unsigned long *PolicyInformation)
1008 {
1009     UNIMPLEMENTED;
1010     return STATUS_NOT_IMPLEMENTED;
1011 }
1012
1013
1014 /* Function 49 */
1015 NTSTATUS WINAPI LsarSetTrustedDomainInfoByName(
1016     LSAPR_HANDLE PolicyHandle,
1017     PRPC_UNICODE_STRING TrustedDomainName,
1018     POLICY_INFORMATION_CLASS InformationClass,
1019     unsigned long PolicyInformation)
1020 {
1021     UNIMPLEMENTED;
1022     return STATUS_NOT_IMPLEMENTED;
1023 }
1024
1025
1026 /* Function 50 */
1027 NTSTATUS WINAPI LsarEnumerateTrustedDomainsEx(
1028     LSAPR_HANDLE PolicyHandle,
1029     DWORD *EnumerationContext,
1030     PLSAPR_TRUSTED_ENUM_BUFFER_EX EnumerationBuffer,
1031     DWORD PreferedMaximumLength)
1032 {
1033     UNIMPLEMENTED;
1034     return STATUS_NOT_IMPLEMENTED;
1035 }
1036
1037
1038 /* Function 51 */
1039 NTSTATUS WINAPI LsarCreateTrustedDomainEx(
1040     LSAPR_HANDLE PolicyHandle,
1041     PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
1042     PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION AuthentificationInformation,
1043     ACCESS_MASK DesiredAccess,
1044     LSAPR_HANDLE *TrustedDomainHandle)
1045 {
1046     UNIMPLEMENTED;
1047     return STATUS_NOT_IMPLEMENTED;
1048 }
1049
1050
1051 /* Function 52 */
1052 NTSTATUS WINAPI LsarSetPolicyReplicationHandle(
1053     PLSAPR_HANDLE PolicyHandle)
1054 {
1055     /* Deprecated */
1056     return STATUS_NOT_IMPLEMENTED;
1057 }
1058
1059
1060 /* Function 53 */
1061 NTSTATUS WINAPI LsarQueryDomainInformationPolicy(
1062     LSAPR_HANDLE PolicyHandle,
1063     POLICY_INFORMATION_CLASS InformationClass,
1064     unsigned long *PolicyInformation)
1065 {
1066     UNIMPLEMENTED;
1067     return STATUS_NOT_IMPLEMENTED;
1068 }
1069
1070
1071 /* Function 54 */
1072 NTSTATUS WINAPI LsarSetDomainInformationPolicy(
1073     LSAPR_HANDLE PolicyHandle,
1074     POLICY_INFORMATION_CLASS InformationClass,
1075     unsigned long PolicyInformation)
1076 {
1077     UNIMPLEMENTED;
1078     return STATUS_NOT_IMPLEMENTED;
1079 }
1080
1081
1082 /* Function 55 */
1083 NTSTATUS WINAPI LsarOpenTrustedDomainByName(
1084     LSAPR_HANDLE PolicyHandle,
1085     PRPC_UNICODE_STRING TrustedDomainName,
1086     ACCESS_MASK DesiredAccess,
1087     LSAPR_HANDLE *TrustedDomainHandle)
1088 {
1089     UNIMPLEMENTED;
1090     return STATUS_NOT_IMPLEMENTED;
1091 }
1092
1093
1094 /* Function 56 */
1095 NTSTATUS WINAPI LsarTestCall(
1096     handle_t hBinding)
1097 {
1098     UNIMPLEMENTED;
1099     return STATUS_NOT_IMPLEMENTED;
1100 }
1101
1102
1103 /* Function 57 */
1104 NTSTATUS WINAPI LsarLookupSids2(
1105     LSAPR_HANDLE PolicyHandle,
1106     PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
1107     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1108     PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,
1109     LSAP_LOOKUP_LEVEL LookupLevel,
1110     DWORD *MappedCount,
1111     DWORD LookupOptions,
1112     DWORD ClientRevision)
1113 {
1114     UNIMPLEMENTED;
1115     return STATUS_NOT_IMPLEMENTED;
1116 }
1117
1118
1119 /* Function 58 */
1120 NTSTATUS WINAPI LsarLookupNames2(
1121     LSAPR_HANDLE PolicyHandle,
1122     DWORD Count,
1123     PRPC_UNICODE_STRING Names,
1124     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1125     PLSAPR_TRANSLATED_SIDS_EX TranslatedSids,
1126     LSAP_LOOKUP_LEVEL LookupLevel,
1127     DWORD *MappedCount,
1128     DWORD LookupOptions,
1129     DWORD ClientRevision)
1130 {
1131     UNIMPLEMENTED;
1132     return STATUS_NOT_IMPLEMENTED;
1133 }
1134
1135
1136 /* Function 59 */
1137 NTSTATUS WINAPI LsarCreateTrustedDomainEx2(
1138     LSAPR_HANDLE PolicyHandle,
1139     PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
1140     PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION_INTERNAL AuthentificationInformation,
1141     ACCESS_MASK DesiredAccess,
1142     LSAPR_HANDLE *TrustedDomainHandle)
1143 {
1144     UNIMPLEMENTED;
1145     return STATUS_NOT_IMPLEMENTED;
1146 }
1147
1148
1149 /* Function 60 */
1150 NTSTATUS WINAPI CredrWrite(
1151     handle_t hBinding)
1152 {
1153     UNIMPLEMENTED;
1154     return STATUS_NOT_IMPLEMENTED;
1155 }
1156
1157
1158 /* Function 61 */
1159 NTSTATUS WINAPI CredrRead(
1160     handle_t hBinding)
1161 {
1162     UNIMPLEMENTED;
1163     return STATUS_NOT_IMPLEMENTED;
1164 }
1165
1166
1167 /* Function 62 */
1168 NTSTATUS WINAPI CredrEnumerate(
1169     handle_t hBinding)
1170 {
1171     UNIMPLEMENTED;
1172     return STATUS_NOT_IMPLEMENTED;
1173 }
1174
1175
1176 /* Function 63 */
1177 NTSTATUS WINAPI CredrWriteDomainCredentials(
1178     handle_t hBinding)
1179 {
1180     UNIMPLEMENTED;
1181     return STATUS_NOT_IMPLEMENTED;
1182 }
1183
1184
1185 /* Function 64 */
1186 NTSTATUS WINAPI CredrReadDomainCredentials(
1187     handle_t hBinding)
1188 {
1189     UNIMPLEMENTED;
1190     return STATUS_NOT_IMPLEMENTED;
1191 }
1192
1193
1194 /* Function 65 */
1195 NTSTATUS WINAPI CredrDelete(
1196     handle_t hBinding)
1197 {
1198     UNIMPLEMENTED;
1199     return STATUS_NOT_IMPLEMENTED;
1200 }
1201
1202
1203 /* Function 66 */
1204 NTSTATUS WINAPI CredrGetTargetInfo(
1205     handle_t hBinding)
1206 {
1207     UNIMPLEMENTED;
1208     return STATUS_NOT_IMPLEMENTED;
1209 }
1210
1211
1212 /* Function 67 */
1213 NTSTATUS WINAPI CredrProfileLoaded(
1214     handle_t hBinding)
1215 {
1216     UNIMPLEMENTED;
1217     return STATUS_NOT_IMPLEMENTED;
1218 }
1219
1220
1221 /* Function 68 */
1222 NTSTATUS WINAPI LsarLookupNames3(
1223     LSAPR_HANDLE PolicyHandle,
1224     DWORD Count,
1225     PRPC_UNICODE_STRING Names,
1226     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1227     PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,
1228     LSAP_LOOKUP_LEVEL LookupLevel,
1229     DWORD *MappedCount,
1230     DWORD LookupOptions,
1231     DWORD ClientRevision)
1232 {
1233     SID_IDENTIFIER_AUTHORITY IdentifierAuthority = {SECURITY_NT_AUTHORITY};
1234     static const UNICODE_STRING DomainName = RTL_CONSTANT_STRING(L"DOMAIN");
1235     PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer = NULL;
1236     PLSAPR_TRANSLATED_SID_EX2 SidsBuffer = NULL;
1237     ULONG SidsBufferLength;
1238     ULONG DomainSidLength;
1239     ULONG AccountSidLength;
1240     PSID DomainSid;
1241     PSID AccountSid;
1242     ULONG i;
1243     NTSTATUS Status;
1244
1245     TRACE("LsarLookupNames3(%p, %lu, %p, %p, %p, %d, %p, %lu, %lu)\n",
1246           PolicyHandle, Count, Names, ReferencedDomains, TranslatedSids,
1247           LookupLevel, MappedCount, LookupOptions, ClientRevision);
1248
1249     if (Count == 0)
1250         return STATUS_NONE_MAPPED;
1251
1252     TranslatedSids->Entries = Count;
1253     TranslatedSids->Sids = NULL;
1254     *ReferencedDomains = NULL;
1255
1256     SidsBufferLength = Count * sizeof(LSAPR_TRANSLATED_SID_EX2);
1257     SidsBuffer = MIDL_user_allocate(SidsBufferLength);
1258     if (SidsBuffer == NULL)
1259         return STATUS_INSUFFICIENT_RESOURCES;
1260
1261     for (i = 0; i < Count; i++)
1262     {
1263         SidsBuffer[i].Use = SidTypeUser;
1264         SidsBuffer[i].Sid = NULL;
1265         SidsBuffer[i].DomainIndex = -1;
1266         SidsBuffer[i].Flags = 0;
1267     }
1268
1269     DomainsBuffer = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
1270     if (DomainsBuffer == NULL)
1271     {
1272         MIDL_user_free(SidsBuffer);
1273         return STATUS_INSUFFICIENT_RESOURCES;
1274     }
1275
1276     DomainsBuffer->Entries = Count;
1277     DomainsBuffer->Domains = MIDL_user_allocate(Count * sizeof(LSA_TRUST_INFORMATION));
1278     if (DomainsBuffer->Domains == NULL)
1279     {
1280         MIDL_user_free(DomainsBuffer);
1281         MIDL_user_free(SidsBuffer);
1282         return STATUS_INSUFFICIENT_RESOURCES;
1283     }
1284
1285     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
1286                                          2,
1287                                          SECURITY_BUILTIN_DOMAIN_RID,
1288                                          DOMAIN_ALIAS_RID_ADMINS,
1289                                          0, 0, 0, 0, 0, 0,
1290                                          &DomainSid);
1291     if (!NT_SUCCESS(Status))
1292     {
1293         MIDL_user_free(DomainsBuffer->Domains);
1294         MIDL_user_free(DomainsBuffer);
1295         MIDL_user_free(SidsBuffer);
1296         return Status;
1297     }
1298
1299     DomainSidLength = RtlLengthSid(DomainSid);
1300
1301     for (i = 0; i < Count; i++)
1302     {
1303         DomainsBuffer->Domains[i].Sid = MIDL_user_allocate(DomainSidLength);
1304         RtlCopyMemory(DomainsBuffer->Domains[i].Sid,
1305                       DomainSid,
1306                       DomainSidLength);
1307
1308         DomainsBuffer->Domains[i].Name.Buffer = MIDL_user_allocate(DomainName.MaximumLength);
1309         DomainsBuffer->Domains[i].Name.Length = DomainName.Length;
1310         DomainsBuffer->Domains[i].Name.MaximumLength = DomainName.MaximumLength;
1311         RtlCopyMemory(DomainsBuffer->Domains[i].Name.Buffer,
1312                       DomainName.Buffer,
1313                       DomainName.MaximumLength);
1314     }
1315
1316     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
1317                                          3,
1318                                          SECURITY_BUILTIN_DOMAIN_RID,
1319                                          DOMAIN_ALIAS_RID_ADMINS,
1320                                          DOMAIN_USER_RID_ADMIN,
1321                                          0, 0, 0, 0, 0,
1322                                          &AccountSid);
1323     if (!NT_SUCCESS(Status))
1324     {
1325         MIDL_user_free(DomainsBuffer->Domains);
1326         MIDL_user_free(DomainsBuffer);
1327         MIDL_user_free(SidsBuffer);
1328         return Status;
1329     }
1330
1331     AccountSidLength = RtlLengthSid(AccountSid);
1332
1333     for (i = 0; i < Count; i++)
1334     {
1335         SidsBuffer[i].Use = SidTypeWellKnownGroup;
1336         SidsBuffer[i].Sid = MIDL_user_allocate(AccountSidLength);
1337
1338         RtlCopyMemory(SidsBuffer[i].Sid,
1339                       AccountSid,
1340                       AccountSidLength);
1341
1342         SidsBuffer[i].DomainIndex = i;
1343         SidsBuffer[i].Flags = 0;
1344     }
1345
1346     *ReferencedDomains = DomainsBuffer;
1347     *MappedCount = Count;
1348
1349     TranslatedSids->Entries = Count;
1350     TranslatedSids->Sids = SidsBuffer;
1351
1352     return STATUS_SUCCESS;
1353 }
1354
1355
1356 /* Function 69 */
1357 NTSTATUS WINAPI CredrGetSessionTypes(
1358     handle_t hBinding)
1359 {
1360     UNIMPLEMENTED;
1361     return STATUS_NOT_IMPLEMENTED;
1362 }
1363
1364
1365 /* Function 70 */
1366 NTSTATUS WINAPI LsarRegisterAuditEvent(
1367     handle_t hBinding)
1368 {
1369     UNIMPLEMENTED;
1370     return STATUS_NOT_IMPLEMENTED;
1371 }
1372
1373
1374 /* Function 71 */
1375 NTSTATUS WINAPI LsarGenAuditEvent(
1376     handle_t hBinding)
1377 {
1378     UNIMPLEMENTED;
1379     return STATUS_NOT_IMPLEMENTED;
1380 }
1381
1382
1383 /* Function 72 */
1384 NTSTATUS WINAPI LsarUnregisterAuditEvent(
1385     handle_t hBinding)
1386 {
1387     UNIMPLEMENTED;
1388     return STATUS_NOT_IMPLEMENTED;
1389 }
1390
1391
1392 /* Function 73 */
1393 NTSTATUS WINAPI LsarQueryForestTrustInformation(
1394     LSAPR_HANDLE PolicyHandle,
1395     PLSA_UNICODE_STRING TrustedDomainName,
1396     LSA_FOREST_TRUST_RECORD_TYPE HighestRecordType,
1397     PLSA_FOREST_TRUST_INFORMATION *ForestTrustInfo)
1398 {
1399     UNIMPLEMENTED;
1400     return STATUS_NOT_IMPLEMENTED;
1401 }
1402
1403
1404 /* Function 74 */
1405 NTSTATUS WINAPI LsarSetForestTrustInformation(
1406     LSAPR_HANDLE PolicyHandle,
1407     PLSA_UNICODE_STRING TrustedDomainName,
1408     LSA_FOREST_TRUST_RECORD_TYPE HighestRecordType,
1409     PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
1410     BOOL CheckOnly,
1411     PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
1412 {
1413     UNIMPLEMENTED;
1414     return STATUS_NOT_IMPLEMENTED;
1415 }
1416
1417
1418 /* Function 75 */
1419 NTSTATUS WINAPI CredrRename(
1420     handle_t hBinding)
1421 {
1422     UNIMPLEMENTED;
1423     return STATUS_NOT_IMPLEMENTED;
1424 }
1425
1426
1427 /* Function 76 */
1428 NTSTATUS WINAPI LsarLookupSids3(
1429     LSAPR_HANDLE PolicyHandle,
1430     PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
1431     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1432     PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,
1433     LSAP_LOOKUP_LEVEL LookupLevel,
1434     DWORD *MappedCount,
1435     DWORD LookupOptions,
1436     DWORD ClientRevision)
1437 {
1438     UNIMPLEMENTED;
1439     return STATUS_NOT_IMPLEMENTED;
1440 }
1441
1442
1443 /* Function 77 */
1444 NTSTATUS WINAPI LsarLookupNames4(
1445     handle_t RpcHandle,
1446     DWORD Count,
1447     PRPC_UNICODE_STRING Names,
1448     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1449     PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,
1450     LSAP_LOOKUP_LEVEL LookupLevel,
1451     DWORD *MappedCount,
1452     DWORD LookupOptions,
1453     DWORD ClientRevision)
1454 {
1455     UNIMPLEMENTED;
1456     return STATUS_NOT_IMPLEMENTED;
1457 }
1458
1459
1460 /* Function 78 */
1461 NTSTATUS WINAPI LsarOpenPolicySce(
1462     handle_t hBinding)
1463 {
1464     UNIMPLEMENTED;
1465     return STATUS_NOT_IMPLEMENTED;
1466 }
1467
1468
1469 /* Function 79 */
1470 NTSTATUS WINAPI LsarAdtRegisterSecurityEventSource(
1471     handle_t hBinding)
1472 {
1473     UNIMPLEMENTED;
1474     return STATUS_NOT_IMPLEMENTED;
1475 }
1476
1477
1478 /* Function 80 */
1479 NTSTATUS WINAPI LsarAdtUnregisterSecurityEventSource(
1480     handle_t hBinding)
1481 {
1482     UNIMPLEMENTED;
1483     return STATUS_NOT_IMPLEMENTED;
1484 }
1485
1486
1487 /* Function 81 */
1488 NTSTATUS WINAPI LsarAdtReportSecurityEvent(
1489     handle_t hBinding)
1490 {
1491     UNIMPLEMENTED;
1492     return STATUS_NOT_IMPLEMENTED;
1493 }
1494
1495
1496 /* Function 82 */
1497 NTSTATUS WINAPI CredrFindBestCredential(
1498     handle_t hBinding)
1499 {
1500     UNIMPLEMENTED;
1501     return STATUS_NOT_IMPLEMENTED;
1502 }
1503
1504
1505 /* Function 83 */
1506 NTSTATUS WINAPI LsarSetAuditPolicy(
1507     handle_t hBinding)
1508 {
1509     UNIMPLEMENTED;
1510     return STATUS_NOT_IMPLEMENTED;
1511 }
1512
1513
1514 /* Function 84 */
1515 NTSTATUS WINAPI LsarQueryAuditPolicy(
1516     handle_t hBinding)
1517 {
1518     UNIMPLEMENTED;
1519     return STATUS_NOT_IMPLEMENTED;
1520 }
1521
1522
1523 /* Function 85 */
1524 NTSTATUS WINAPI LsarEnumerateAuditPolicy(
1525     handle_t hBinding)
1526 {
1527     UNIMPLEMENTED;
1528     return STATUS_NOT_IMPLEMENTED;
1529 }
1530
1531
1532 /* Function 86 */
1533 NTSTATUS WINAPI LsarEnumerateAuditCategories(
1534     handle_t hBinding)
1535 {
1536     UNIMPLEMENTED;
1537     return STATUS_NOT_IMPLEMENTED;
1538 }
1539
1540
1541 /* Function 87 */
1542 NTSTATUS WINAPI LsarEnumerateAuditSubCategories(
1543     handle_t hBinding)
1544 {
1545     UNIMPLEMENTED;
1546     return STATUS_NOT_IMPLEMENTED;
1547 }
1548
1549
1550 /* Function 88 */
1551 NTSTATUS WINAPI LsarLookupAuditCategoryName(
1552     handle_t hBinding)
1553 {
1554     UNIMPLEMENTED;
1555     return STATUS_NOT_IMPLEMENTED;
1556 }
1557
1558
1559 /* Function 89 */
1560 NTSTATUS WINAPI LsarLookupAuditSubCategoryName(
1561     handle_t hBinding)
1562 {
1563     UNIMPLEMENTED;
1564     return STATUS_NOT_IMPLEMENTED;
1565 }
1566
1567
1568 /* Function 90 */
1569 NTSTATUS WINAPI LsarSetAuditSecurity(
1570     handle_t hBinding)
1571 {
1572     UNIMPLEMENTED;
1573     return STATUS_NOT_IMPLEMENTED;
1574 }
1575
1576
1577 /* Function 91 */
1578 NTSTATUS WINAPI LsarQueryAuditSecurity(
1579     handle_t hBinding)
1580 {
1581     UNIMPLEMENTED;
1582     return STATUS_NOT_IMPLEMENTED;
1583 }
1584
1585
1586 /* Function 92 */
1587 NTSTATUS WINAPI CredReadByTokenHandle(
1588     handle_t hBinding)
1589 {
1590     UNIMPLEMENTED;
1591     return STATUS_NOT_IMPLEMENTED;
1592 }
1593
1594
1595 /* Function 93 */
1596 NTSTATUS WINAPI CredrRestoreCredentials(
1597     handle_t hBinding)
1598 {
1599     UNIMPLEMENTED;
1600     return STATUS_NOT_IMPLEMENTED;
1601 }
1602
1603
1604 /* Function 94 */
1605 NTSTATUS WINAPI CredrBackupCredentials(
1606     handle_t hBinding)
1607 {
1608     UNIMPLEMENTED;
1609     return STATUS_NOT_IMPLEMENTED;
1610 }
1611
1612 /* EOF */