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     UNIMPLEMENTED;
 314     return STATUS_NOT_IMPLEMENTED;
 315 }
 316
 317
 318 /* Function 11 */
 319 NTSTATUS WINAPI LsarEnumerateAccounts(
 320     LSAPR_HANDLE PolicyHandle,
 321     DWORD *EnumerationContext,
 322     PLSAPR_ACCOUNT_ENUM_BUFFER EnumerationBuffer,
 323     DWORD PreferedMaximumLength)
 324 {
 325     UNIMPLEMENTED;
 326     return STATUS_NOT_IMPLEMENTED;
 327 }
 328
 329
 330 /* Function 12 */
 331 NTSTATUS WINAPI LsarCreateTrustedDomain(
 332     LSAPR_HANDLE PolicyHandle,
 333     PLSAPR_TRUST_INFORMATION TrustedDomainInformation,
 334     ACCESS_MASK DesiredAccess,
 335     LSAPR_HANDLE *TrustedDomainHandle)
 336 {
 337     UNIMPLEMENTED;
 338     return STATUS_NOT_IMPLEMENTED;
 339 }
 340
 341
 342 /* Function 13 */
 343 NTSTATUS WINAPI LsarEnumerateTrustedDomains(
 344     LSAPR_HANDLE PolicyHandle,
 345     DWORD *EnumerationContext,
 346     PLSAPR_TRUSTED_ENUM_BUFFER EnumerationBuffer,
 347     DWORD PreferedMaximumLength)
 348 {
 349     UNIMPLEMENTED;
 350     return STATUS_NOT_IMPLEMENTED;
 351 }
 352
 353
 354 /* Function 14 */
 355 NTSTATUS WINAPI LsarLookupNames(
 356     LSAPR_HANDLE PolicyHandle,
 357     DWORD Count,
 358     PRPC_UNICODE_STRING Names,
 359     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 360     PLSAPR_TRANSLATED_SIDS TranslatedSids,
 361     LSAP_LOOKUP_LEVEL LookupLevel,
 362     DWORD *MappedCount)
 363 {
 364     SID_IDENTIFIER_AUTHORITY IdentifierAuthority = {SECURITY_NT_AUTHORITY};
 365     static const UNICODE_STRING DomainName = RTL_CONSTANT_STRING(L"DOMAIN");
 366     PLSAPR_REFERENCED_DOMAIN_LIST OutputDomains = NULL;
 367     PLSA_TRANSLATED_SID OutputSids = NULL;
 368     ULONG OutputSidsLength;
 369     ULONG i;
 370     PSID Sid;
 371     ULONG SidLength;
 372     NTSTATUS Status;
 373
 374     TRACE("LsarLookupNames(%p, %lu, %p, %p, %p, %d, %p)\n",
 375           PolicyHandle, Count, Names, ReferencedDomains, TranslatedSids,
 376           LookupLevel, MappedCount);
 377
 378     TranslatedSids->Entries = Count;
 379     TranslatedSids->Sids = NULL;
 380     *ReferencedDomains = NULL;
 381
 382     OutputSidsLength = Count * sizeof(LSA_TRANSLATED_SID);
 383     OutputSids = MIDL_user_allocate(OutputSidsLength);
 384     if (OutputSids == NULL)
 385     {
 386         return STATUS_INSUFFICIENT_RESOURCES;
 387     }
 388
 389     RtlZeroMemory(OutputSids, OutputSidsLength);
 390
 391     OutputDomains = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
 392     if (OutputDomains == NULL)
 393     {
 394         MIDL_user_free(OutputSids);
 395         return STATUS_INSUFFICIENT_RESOURCES;
 396     }
 397
 398     OutputDomains->Entries = Count;
 399     OutputDomains->Domains = MIDL_user_allocate(Count * sizeof(LSA_TRUST_INFORMATION));
 400     if (OutputDomains->Domains == NULL)
 401     {
 402         MIDL_user_free(OutputDomains);
 403         MIDL_user_free(OutputSids);
 404         return STATUS_INSUFFICIENT_RESOURCES;
 405     }
 406
 407     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
 408                                          2,
 409                                          SECURITY_BUILTIN_DOMAIN_RID,
 410                                          DOMAIN_ALIAS_RID_ADMINS,
 411                                          0, 0, 0, 0, 0, 0,
 412                                          &Sid);
 413     if (!NT_SUCCESS(Status))
 414     {
 415         MIDL_user_free(OutputDomains->Domains);
 416         MIDL_user_free(OutputDomains);
 417         MIDL_user_free(OutputSids);
 418         return Status;
 419     }
 420
 421     SidLength = RtlLengthSid(Sid);
 422
 423     for (i = 0; i < Count; i++)
 424     {
 425         OutputDomains->Domains[i].Sid = MIDL_user_allocate(SidLength);
 426         RtlCopyMemory(OutputDomains->Domains[i].Sid, Sid, SidLength);
 427
 428         OutputDomains->Domains[i].Name.Buffer = MIDL_user_allocate(DomainName.MaximumLength);
 429         OutputDomains->Domains[i].Name.Length = DomainName.Length;
 430         OutputDomains->Domains[i].Name.MaximumLength = DomainName.MaximumLength;
 431         RtlCopyMemory(OutputDomains->Domains[i].Name.Buffer, DomainName.Buffer, DomainName.MaximumLength);
 432     }
 433
 434     for (i = 0; i < Count; i++)
 435     {
 436         OutputSids[i].Use = SidTypeWellKnownGroup;
 437         OutputSids[i].RelativeId = DOMAIN_USER_RID_ADMIN; //DOMAIN_ALIAS_RID_ADMINS;
 438         OutputSids[i].DomainIndex = i;
 439     }
 440
 441     *ReferencedDomains = OutputDomains;
 442
 443     *MappedCount = Count;
 444
 445     TranslatedSids->Entries = Count;
 446     TranslatedSids->Sids = OutputSids;
 447
 448     return STATUS_SUCCESS;
 449 }
 450
 451
 452 /* Function 15 */
 453 NTSTATUS WINAPI LsarLookupSids(
 454     LSAPR_HANDLE PolicyHandle,
 455     PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
 456     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 457     PLSAPR_TRANSLATED_NAMES TranslatedNames,
 458     LSAP_LOOKUP_LEVEL LookupLevel,
 459     DWORD *MappedCount)
 460 {
 461     SID_IDENTIFIER_AUTHORITY IdentifierAuthority = {SECURITY_NT_AUTHORITY};
 462     static const UNICODE_STRING DomainName = RTL_CONSTANT_STRING(L"DOMAIN");
 463     PLSAPR_REFERENCED_DOMAIN_LIST OutputDomains = NULL;
 464     PLSAPR_TRANSLATED_NAME OutputNames = NULL;
 465     ULONG OutputNamesLength;
 466     ULONG i;
 467     PSID Sid;
 468     ULONG SidLength;
 469     NTSTATUS Status;
 470
 471     TRACE("LsarLookupSids(%p, %p, %p, %p, %d, %p)\n",
 472           PolicyHandle, SidEnumBuffer, ReferencedDomains, TranslatedNames,
 473           LookupLevel, MappedCount);
 474
 475     TranslatedNames->Entries = SidEnumBuffer->Entries;
 476     TranslatedNames->Names = NULL;
 477     *ReferencedDomains = NULL;
 478
 479     OutputNamesLength = SidEnumBuffer->Entries * sizeof(LSA_TRANSLATED_NAME);
 480     OutputNames = MIDL_user_allocate(OutputNamesLength);
 481     if (OutputNames == NULL)
 482     {
 483         return STATUS_INSUFFICIENT_RESOURCES;
 484     }
 485
 486     RtlZeroMemory(OutputNames, OutputNamesLength);
 487
 488     OutputDomains = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
 489     if (OutputDomains == NULL)
 490     {
 491         MIDL_user_free(OutputNames);
 492         return STATUS_INSUFFICIENT_RESOURCES;
 493     }
 494
 495     OutputDomains->Entries = SidEnumBuffer->Entries;
 496     OutputDomains->Domains = MIDL_user_allocate(SidEnumBuffer->Entries * sizeof(LSA_TRUST_INFORMATION));
 497     if (OutputDomains->Domains == NULL)
 498     {
 499         MIDL_user_free(OutputDomains);
 500         MIDL_user_free(OutputNames);
 501         return STATUS_INSUFFICIENT_RESOURCES;
 502     }
 503
 504     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
 505                                          2,
 506                                          SECURITY_BUILTIN_DOMAIN_RID,
 507                                          DOMAIN_ALIAS_RID_ADMINS,
 508                                          0, 0, 0, 0, 0, 0,
 509                                          &Sid);
 510     if (!NT_SUCCESS(Status))
 511     {
 512         MIDL_user_free(OutputDomains->Domains);
 513         MIDL_user_free(OutputDomains);
 514         MIDL_user_free(OutputNames);
 515         return Status;
 516     }
 517
 518     SidLength = RtlLengthSid(Sid);
 519
 520     for (i = 0; i < SidEnumBuffer->Entries; i++)
 521     {
 522         OutputDomains->Domains[i].Sid = MIDL_user_allocate(SidLength);
 523         RtlCopyMemory(OutputDomains->Domains[i].Sid, Sid, SidLength);
 524
 525         OutputDomains->Domains[i].Name.Buffer = MIDL_user_allocate(DomainName.MaximumLength);
 526         OutputDomains->Domains[i].Name.Length = DomainName.Length;
 527         OutputDomains->Domains[i].Name.MaximumLength = DomainName.MaximumLength;
 528         RtlCopyMemory(OutputDomains->Domains[i].Name.Buffer, DomainName.Buffer, DomainName.MaximumLength);
 529     }
 530
 531     Status = LsapLookupSids(SidEnumBuffer,
 532                             OutputNames);
 533
 534     *ReferencedDomains = OutputDomains;
 535
 536     *MappedCount = SidEnumBuffer->Entries;
 537
 538     TranslatedNames->Entries = SidEnumBuffer->Entries;
 539     TranslatedNames->Names = OutputNames;
 540
 541     return Status;
 542 }
 543
 544
 545 /* Function 16 */
 546 NTSTATUS WINAPI LsarCreateSecret(
 547     LSAPR_HANDLE PolicyHandle,
 548     PRPC_UNICODE_STRING SecretName,
 549     ACCESS_MASK DesiredAccess,
 550     LSAPR_HANDLE *SecretHandle)
 551 {
 552     UNIMPLEMENTED;
 553     return STATUS_NOT_IMPLEMENTED;
 554 }
 555
 556
 557 /* Function 17 */
 558 NTSTATUS WINAPI LsarOpenAccount(
 559     LSAPR_HANDLE PolicyHandle,
 560     PRPC_SID AccountSid,
 561     ACCESS_MASK DesiredAccess,
 562     LSAPR_HANDLE *AccountHandle)
 563 {
 564     UNIMPLEMENTED;
 565     return STATUS_NOT_IMPLEMENTED;
 566 }
 567
 568
 569 /* Function 18 */
 570 NTSTATUS WINAPI LsarEnumeratePrivilegesAccount(
 571     LSAPR_HANDLE AccountHandle,
 572     PLSAPR_PRIVILEGE_SET *Privileges)
 573 {
 574     UNIMPLEMENTED;
 575     return STATUS_NOT_IMPLEMENTED;
 576 }
 577
 578
 579 /* Function 19 */
 580 NTSTATUS WINAPI LsarAddPrivilegesToAccount(
 581     LSAPR_HANDLE AccountHandle,
 582     PLSAPR_PRIVILEGE_SET Privileges)
 583 {
 584     UNIMPLEMENTED;
 585     return STATUS_NOT_IMPLEMENTED;
 586 }
 587
 588
 589 /* Function 20 */
 590 NTSTATUS WINAPI LsarRemovePrivilegesFromAccount(
 591     LSAPR_HANDLE AccountHandle,
 592     BOOL AllPrivileges,
 593     PLSAPR_PRIVILEGE_SET Privileges)
 594 {
 595     UNIMPLEMENTED;
 596     return STATUS_NOT_IMPLEMENTED;
 597 }
 598
 599
 600 /* Function 21 */
 601 NTSTATUS WINAPI LsarGetQuotasForAccount(
 602     LSAPR_HANDLE AccountHandle,
 603     PQUOTA_LIMITS QuotaLimits)
 604 {
 605     UNIMPLEMENTED;
 606     return STATUS_NOT_IMPLEMENTED;
 607 }
 608
 609
 610 /* Function 22 */
 611 NTSTATUS WINAPI LsarSetQuotasForAccount(
 612     LSAPR_HANDLE AccountHandle,
 613     PQUOTA_LIMITS QuotaLimits)
 614 {
 615     UNIMPLEMENTED;
 616     return STATUS_NOT_IMPLEMENTED;
 617 }
 618
 619
 620 /* Function 23 */
 621 NTSTATUS WINAPI LsarGetSystemAccessAccount(
 622     LSAPR_HANDLE AccountHandle,
 623     ACCESS_MASK *SystemAccess)
 624 {
 625     UNIMPLEMENTED;
 626     return STATUS_NOT_IMPLEMENTED;
 627 }
 628
 629
 630 /* Function 24 */
 631 NTSTATUS WINAPI LsarSetSystemAccessAccount(
 632     LSAPR_HANDLE AccountHandle,
 633     ACCESS_MASK SystemAccess)
 634 {
 635     UNIMPLEMENTED;
 636     return STATUS_NOT_IMPLEMENTED;
 637 }
 638
 639
 640 /* Function 25 */
 641 NTSTATUS WINAPI LsarOpenTrustedDomain(
 642     LSAPR_HANDLE PolicyHandle,
 643     PRPC_SID TrustedDomainSid,
 644     ACCESS_MASK DesiredAccess,
 645     LSAPR_HANDLE *TrustedDomainHandle)
 646 {
 647     UNIMPLEMENTED;
 648     return STATUS_NOT_IMPLEMENTED;
 649 }
 650
 651
 652 /* Function 26 */
 653 NTSTATUS WINAPI LsarQueryInfoTrustedDomain(
 654     LSAPR_HANDLE TrustedDomainHandle,
 655     TRUSTED_INFORMATION_CLASS InformationClass,
 656     PLSAPR_TRUSTED_DOMAIN_INFO *TrustedDomainInformation)
 657 {
 658     UNIMPLEMENTED;
 659     return STATUS_NOT_IMPLEMENTED;
 660 }
 661
 662
 663 /* Function 27 */
 664 NTSTATUS WINAPI LsarSetInformationTrustedDomain(
 665     LSAPR_HANDLE TrustedDomainHandle,
 666     TRUSTED_INFORMATION_CLASS InformationClass,
 667     PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation)
 668 {
 669     UNIMPLEMENTED;
 670     return STATUS_NOT_IMPLEMENTED;
 671 }
 672
 673
 674 /* Function 28 */
 675 NTSTATUS WINAPI LsarOpenSecret(
 676     LSAPR_HANDLE PolicyHandle,
 677     PRPC_UNICODE_STRING SecretName,
 678     ACCESS_MASK DesiredAccess,
 679     LSAPR_HANDLE *SecretHandle)
 680 {
 681     UNIMPLEMENTED;
 682     return STATUS_NOT_IMPLEMENTED;
 683 }
 684
 685
 686 /* Function 29 */
 687 NTSTATUS WINAPI LsarSetSecret(
 688     LSAPR_HANDLE *SecretHandle,
 689     PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue,
 690     PLSAPR_CR_CIPHER_VALUE EncryptedOldValue)
 691 {
 692     UNIMPLEMENTED;
 693     return STATUS_NOT_IMPLEMENTED;
 694 }
 695
 696
 697 /* Function 30 */
 698 NTSTATUS WINAPI LsarQuerySecret(
 699     LSAPR_HANDLE SecretHandle,
 700     PLSAPR_CR_CIPHER_VALUE *EncryptedCurrentValue,
 701     PLARGE_INTEGER CurrentValueSetTime,
 702     PLSAPR_CR_CIPHER_VALUE *EncryptedOldValue,
 703     PLARGE_INTEGER OldValueSetTime)
 704 {
 705     UNIMPLEMENTED;
 706     return STATUS_NOT_IMPLEMENTED;
 707 }
 708
 709
 710 /* Function 31 */
 711 NTSTATUS WINAPI LsarLookupPrivilegeValue(
 712     LSAPR_HANDLE PolicyHandle,
 713     PRPC_UNICODE_STRING Name,
 714     PLUID Value)
 715 {
 716     NTSTATUS Status;
 717
 718     TRACE("LsarLookupPrivilegeValue(%p, %wZ, %p)\n",
 719           PolicyHandle, Name, Value);
 720
 721     Status = LsapValidateDbObject(PolicyHandle,
 722                                   LsaDbPolicyObject,
 723                                   0); /* FIXME */
 724     if (!NT_SUCCESS(Status))
 725     {
 726         ERR("Invalid handle (Status %lx)\n", Status);
 727         return Status;
 728     }
 729
 730     TRACE("Privilege: %wZ\n", Name);
 731
 732     Status = LsarpLookupPrivilegeValue((PUNICODE_STRING)Name,
 733                                        Value);
 734
 735     return Status;
 736 }
 737
 738
 739 /* Function 32 */
 740 NTSTATUS WINAPI LsarLookupPrivilegeName(
 741     LSAPR_HANDLE PolicyHandle,
 742     PLUID Value,
 743     PRPC_UNICODE_STRING *Name)
 744 {
 745     NTSTATUS Status;
 746
 747     TRACE("LsarLookupPrivilegeName(%p, %p, %p)\n",
 748           PolicyHandle, Value, Name);
 749
 750     Status = LsapValidateDbObject(PolicyHandle,
 751                                   LsaDbPolicyObject,
 752                                   0); /* FIXME */
 753     if (!NT_SUCCESS(Status))
 754     {
 755         ERR("Invalid handle\n");
 756         return Status;
 757     }
 758
 759     Status = LsarpLookupPrivilegeName(Value, (PUNICODE_STRING*)Name);
 760
 761     return Status;
 762 }
 763
 764
 765 /* Function 33 */
 766 NTSTATUS WINAPI LsarLookupPrivilegeDisplayName(
 767     LSAPR_HANDLE PolicyHandle,
 768     PRPC_UNICODE_STRING Name,
 769     USHORT ClientLanguage,
 770     USHORT ClientSystemDefaultLanguage,
 771     PRPC_UNICODE_STRING *DisplayName,
 772     USHORT *LanguageReturned)
 773 {
 774     UNIMPLEMENTED;
 775     return STATUS_NOT_IMPLEMENTED;
 776 }
 777
 778
 779 /* Function 34 */
 780 NTSTATUS WINAPI LsarDeleteObject(
 781     LSAPR_HANDLE *ObjectHandle)
 782 {
 783     UNIMPLEMENTED;
 784     return STATUS_NOT_IMPLEMENTED;
 785 }
 786
 787
 788 /* Function 35 */
 789 NTSTATUS WINAPI LsarEnumerateAccountsWithUserRight(
 790     LSAPR_HANDLE PolicyHandle,
 791     PRPC_UNICODE_STRING UserRight,
 792     PLSAPR_ACCOUNT_ENUM_BUFFER EnumerationBuffer)
 793 {
 794     UNIMPLEMENTED;
 795     return STATUS_NOT_IMPLEMENTED;
 796 }
 797
 798
 799 /* Function 36 */
 800 NTSTATUS WINAPI LsarEnmuerateAccountRights(
 801     LSAPR_HANDLE PolicyHandle,
 802     PRPC_SID AccountSid,
 803     PLSAPR_USER_RIGHT_SET UserRights)
 804 {
 805     NTSTATUS Status;
 806
 807     FIXME("(%p,%p,%p) stub\n", PolicyHandle, AccountSid, UserRights);
 808
 809     Status = LsapValidateDbObject(PolicyHandle,
 810                                   LsaDbPolicyObject,
 811                                   0); /* FIXME */
 812     if (!NT_SUCCESS(Status))
 813         return Status;
 814
 815     UserRights->Entries = 0;
 816     UserRights->UserRights = NULL;
 817     return STATUS_OBJECT_NAME_NOT_FOUND;
 818 }
 819
 820
 821 /* Function 37 */
 822 NTSTATUS WINAPI LsarAddAccountRights(
 823     LSAPR_HANDLE PolicyHandle,
 824     PRPC_SID AccountSid,
 825     PLSAPR_USER_RIGHT_SET UserRights)
 826 {
 827     UNIMPLEMENTED;
 828     return STATUS_NOT_IMPLEMENTED;
 829 }
 830
 831
 832 /* Function 38 */
 833 NTSTATUS WINAPI LsarRemoveAccountRights(
 834     LSAPR_HANDLE PolicyHandle,
 835     PRPC_SID AccountSid,
 836     BOOL AllRights,
 837     PLSAPR_USER_RIGHT_SET UserRights)
 838 {
 839     UNIMPLEMENTED;
 840     return STATUS_NOT_IMPLEMENTED;
 841 }
 842
 843
 844 /* Function 39 */
 845 NTSTATUS WINAPI LsarQueryTrustedDomainInfo(
 846     LSAPR_HANDLE PolicyHandle,
 847     PRPC_SID TrustedDomainSid,
 848     TRUSTED_INFORMATION_CLASS InformationClass,
 849     PLSAPR_TRUSTED_DOMAIN_INFO *TrustedDomainInformation)
 850 {
 851     UNIMPLEMENTED;
 852     return STATUS_NOT_IMPLEMENTED;
 853 }
 854
 855
 856 /* Function 40 */
 857 NTSTATUS WINAPI LsarSetTrustedDomainInfo(
 858     LSAPR_HANDLE PolicyHandle,
 859     PRPC_SID TrustedDomainSid,
 860     TRUSTED_INFORMATION_CLASS InformationClass,
 861     PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation)
 862 {
 863     UNIMPLEMENTED;
 864     return STATUS_NOT_IMPLEMENTED;
 865 }
 866
 867
 868 /* Function 41 */
 869 NTSTATUS WINAPI LsarDeleteTrustedDomain(
 870     LSAPR_HANDLE PolicyHandle,
 871     PRPC_SID TrustedDomainSid)
 872 {
 873     UNIMPLEMENTED;
 874     return STATUS_NOT_IMPLEMENTED;
 875 }
 876
 877
 878 /* Function 42 */
 879 NTSTATUS WINAPI LsarStorePrivateData(
 880     LSAPR_HANDLE PolicyHandle,
 881     PRPC_UNICODE_STRING KeyName,
 882     PLSAPR_CR_CIPHER_VALUE EncryptedData)
 883 {
 884     UNIMPLEMENTED;
 885     return STATUS_NOT_IMPLEMENTED;
 886 }
 887
 888
 889 /* Function 43 */
 890 NTSTATUS WINAPI LsarRetrievePrivateData(
 891     LSAPR_HANDLE PolicyHandle,
 892     PRPC_UNICODE_STRING KeyName,
 893     PLSAPR_CR_CIPHER_VALUE *EncryptedData)
 894 {
 895     UNIMPLEMENTED;
 896     return STATUS_NOT_IMPLEMENTED;
 897 }
 898
 899
 900 /* Function 44 */
 901 NTSTATUS WINAPI LsarOpenPolicy2(
 902     LPWSTR SystemName,
 903     PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,
 904     ACCESS_MASK DesiredAccess,
 905     LSAPR_HANDLE *PolicyHandle)
 906 {
 907     UNIMPLEMENTED;
 908     return STATUS_NOT_IMPLEMENTED;
 909 }
 910
 911
 912 /* Function 45 */
 913 NTSTATUS WINAPI LsarGetUserName(
 914     LPWSTR SystemName,
 915     PRPC_UNICODE_STRING *UserName,
 916     PRPC_UNICODE_STRING *DomainName)
 917 {
 918     UNIMPLEMENTED;
 919     return STATUS_NOT_IMPLEMENTED;
 920 }
 921
 922
 923 /* Function 46 */
 924 NTSTATUS WINAPI LsarQueryInformationPolicy2(
 925     LSAPR_HANDLE PolicyHandle,
 926     POLICY_INFORMATION_CLASS InformationClass,
 927     unsigned long *PolicyInformation)
 928 {
 929     UNIMPLEMENTED;
 930     return STATUS_NOT_IMPLEMENTED;
 931 }
 932
 933
 934 /* Function 47 */
 935 NTSTATUS WINAPI LsarSetInformationPolicy2(
 936     LSAPR_HANDLE PolicyHandle,
 937     POLICY_INFORMATION_CLASS InformationClass,
 938     unsigned long PolicyInformation)
 939 {
 940     UNIMPLEMENTED;
 941     return STATUS_NOT_IMPLEMENTED;
 942 }
 943
 944
 945 /* Function 48 */
 946 NTSTATUS WINAPI LsarQueryTrustedDomainInfoByName(
 947     LSAPR_HANDLE PolicyHandle,
 948     PRPC_UNICODE_STRING TrustedDomainName,
 949     POLICY_INFORMATION_CLASS InformationClass,
 950     unsigned long *PolicyInformation)
 951 {
 952     UNIMPLEMENTED;
 953     return STATUS_NOT_IMPLEMENTED;
 954 }
 955
 956
 957 /* Function 49 */
 958 NTSTATUS WINAPI LsarSetTrustedDomainInfoByName(
 959     LSAPR_HANDLE PolicyHandle,
 960     PRPC_UNICODE_STRING TrustedDomainName,
 961     POLICY_INFORMATION_CLASS InformationClass,
 962     unsigned long PolicyInformation)
 963 {
 964     UNIMPLEMENTED;
 965     return STATUS_NOT_IMPLEMENTED;
 966 }
 967
 968
 969 /* Function 50 */
 970 NTSTATUS WINAPI LsarEnumerateTrustedDomainsEx(
 971     LSAPR_HANDLE PolicyHandle,
 972     DWORD *EnumerationContext,
 973     PLSAPR_TRUSTED_ENUM_BUFFER_EX EnumerationBuffer,
 974     DWORD PreferedMaximumLength)
 975 {
 976     UNIMPLEMENTED;
 977     return STATUS_NOT_IMPLEMENTED;
 978 }
 979
 980
 981 /* Function 51 */
 982 NTSTATUS WINAPI LsarCreateTrustedDomainEx(
 983     LSAPR_HANDLE PolicyHandle,
 984     PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
 985     PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION AuthentificationInformation,
 986     ACCESS_MASK DesiredAccess,
 987     LSAPR_HANDLE *TrustedDomainHandle)
 988 {
 989     UNIMPLEMENTED;
 990     return STATUS_NOT_IMPLEMENTED;
 991 }
 992
 993
 994 /* Function 52 */
 995 NTSTATUS WINAPI LsarSetPolicyReplicationHandle(
 996     PLSAPR_HANDLE PolicyHandle)
 997 {
 998     /* Deprecated */
 999     return STATUS_NOT_IMPLEMENTED;
1000 }
1001
1002
1003 /* Function 53 */
1004 NTSTATUS WINAPI LsarQueryDomainInformationPolicy(
1005     LSAPR_HANDLE PolicyHandle,
1006     POLICY_INFORMATION_CLASS InformationClass,
1007     unsigned long *PolicyInformation)
1008 {
1009     UNIMPLEMENTED;
1010     return STATUS_NOT_IMPLEMENTED;
1011 }
1012
1013
1014 /* Function 54 */
1015 NTSTATUS WINAPI LsarSetDomainInformationPolicy(
1016     LSAPR_HANDLE PolicyHandle,
1017     POLICY_INFORMATION_CLASS InformationClass,
1018     unsigned long PolicyInformation)
1019 {
1020     UNIMPLEMENTED;
1021     return STATUS_NOT_IMPLEMENTED;
1022 }
1023
1024
1025 /* Function 55 */
1026 NTSTATUS WINAPI LsarOpenTrustedDomainByName(
1027     LSAPR_HANDLE PolicyHandle,
1028     PRPC_UNICODE_STRING TrustedDomainName,
1029     ACCESS_MASK DesiredAccess,
1030     LSAPR_HANDLE *TrustedDomainHandle)
1031 {
1032     UNIMPLEMENTED;
1033     return STATUS_NOT_IMPLEMENTED;
1034 }
1035
1036
1037 /* Function 56 */
1038 NTSTATUS WINAPI LsarTestCall(
1039     handle_t hBinding)
1040 {
1041     UNIMPLEMENTED;
1042     return STATUS_NOT_IMPLEMENTED;
1043 }
1044
1045
1046 /* Function 57 */
1047 NTSTATUS WINAPI LsarLookupSids2(
1048     LSAPR_HANDLE PolicyHandle,
1049     PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
1050     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1051     PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,
1052     LSAP_LOOKUP_LEVEL LookupLevel,
1053     DWORD *MappedCount,
1054     DWORD LookupOptions,
1055     DWORD ClientRevision)
1056 {
1057     UNIMPLEMENTED;
1058     return STATUS_NOT_IMPLEMENTED;
1059 }
1060
1061
1062 /* Function 58 */
1063 NTSTATUS WINAPI LsarLookupNames2(
1064     LSAPR_HANDLE PolicyHandle,
1065     DWORD Count,
1066     PRPC_UNICODE_STRING Names,
1067     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1068     PLSAPR_TRANSLATED_SIDS_EX TranslatedSids,
1069     LSAP_LOOKUP_LEVEL LookupLevel,
1070     DWORD *MappedCount,
1071     DWORD LookupOptions,
1072     DWORD ClientRevision)
1073 {
1074     UNIMPLEMENTED;
1075     return STATUS_NOT_IMPLEMENTED;
1076 }
1077
1078
1079 /* Function 59 */
1080 NTSTATUS WINAPI LsarCreateTrustedDomainEx2(
1081     LSAPR_HANDLE PolicyHandle,
1082     PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
1083     PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION_INTERNAL AuthentificationInformation,
1084     ACCESS_MASK DesiredAccess,
1085     LSAPR_HANDLE *TrustedDomainHandle)
1086 {
1087     UNIMPLEMENTED;
1088     return STATUS_NOT_IMPLEMENTED;
1089 }
1090
1091
1092 /* Function 60 */
1093 NTSTATUS WINAPI CredrWrite(
1094     handle_t hBinding)
1095 {
1096     UNIMPLEMENTED;
1097     return STATUS_NOT_IMPLEMENTED;
1098 }
1099
1100
1101 /* Function 61 */
1102 NTSTATUS WINAPI CredrRead(
1103     handle_t hBinding)
1104 {
1105     UNIMPLEMENTED;
1106     return STATUS_NOT_IMPLEMENTED;
1107 }
1108
1109
1110 /* Function 62 */
1111 NTSTATUS WINAPI CredrEnumerate(
1112     handle_t hBinding)
1113 {
1114     UNIMPLEMENTED;
1115     return STATUS_NOT_IMPLEMENTED;
1116 }
1117
1118
1119 /* Function 63 */
1120 NTSTATUS WINAPI CredrWriteDomainCredentials(
1121     handle_t hBinding)
1122 {
1123     UNIMPLEMENTED;
1124     return STATUS_NOT_IMPLEMENTED;
1125 }
1126
1127
1128 /* Function 64 */
1129 NTSTATUS WINAPI CredrReadDomainCredentials(
1130     handle_t hBinding)
1131 {
1132     UNIMPLEMENTED;
1133     return STATUS_NOT_IMPLEMENTED;
1134 }
1135
1136
1137 /* Function 65 */
1138 NTSTATUS WINAPI CredrDelete(
1139     handle_t hBinding)
1140 {
1141     UNIMPLEMENTED;
1142     return STATUS_NOT_IMPLEMENTED;
1143 }
1144
1145
1146 /* Function 66 */
1147 NTSTATUS WINAPI CredrGetTargetInfo(
1148     handle_t hBinding)
1149 {
1150     UNIMPLEMENTED;
1151     return STATUS_NOT_IMPLEMENTED;
1152 }
1153
1154
1155 /* Function 67 */
1156 NTSTATUS WINAPI CredrProfileLoaded(
1157     handle_t hBinding)
1158 {
1159     UNIMPLEMENTED;
1160     return STATUS_NOT_IMPLEMENTED;
1161 }
1162
1163
1164 /* Function 68 */
1165 NTSTATUS WINAPI LsarLookupNames3(
1166     LSAPR_HANDLE PolicyHandle,
1167     DWORD Count,
1168     PRPC_UNICODE_STRING Names,
1169     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1170     PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,
1171     LSAP_LOOKUP_LEVEL LookupLevel,
1172     DWORD *MappedCount,
1173     DWORD LookupOptions,
1174     DWORD ClientRevision)
1175 {
1176     SID_IDENTIFIER_AUTHORITY IdentifierAuthority = {SECURITY_NT_AUTHORITY};
1177     static const UNICODE_STRING DomainName = RTL_CONSTANT_STRING(L"DOMAIN");
1178     PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer = NULL;
1179     PLSAPR_TRANSLATED_SID_EX2 SidsBuffer = NULL;
1180     ULONG SidsBufferLength;
1181     ULONG DomainSidLength;
1182     ULONG AccountSidLength;
1183     PSID DomainSid;
1184     PSID AccountSid;
1185     ULONG i;
1186     NTSTATUS Status;
1187
1188     TRACE("LsarLookupNames3(%p, %lu, %p, %p, %p, %d, %p, %lu, %lu)\n",
1189           PolicyHandle, Count, Names, ReferencedDomains, TranslatedSids,
1190           LookupLevel, MappedCount, LookupOptions, ClientRevision);
1191
1192     if (Count == 0)
1193         return STATUS_NONE_MAPPED;
1194
1195     TranslatedSids->Entries = Count;
1196     TranslatedSids->Sids = NULL;
1197     *ReferencedDomains = NULL;
1198
1199     SidsBufferLength = Count * sizeof(LSAPR_TRANSLATED_SID_EX2);
1200     SidsBuffer = MIDL_user_allocate(SidsBufferLength);
1201     if (SidsBuffer == NULL)
1202         return STATUS_INSUFFICIENT_RESOURCES;
1203
1204     for (i = 0; i < Count; i++)
1205     {
1206         SidsBuffer[i].Use = SidTypeUser;
1207         SidsBuffer[i].Sid = NULL;
1208         SidsBuffer[i].DomainIndex = -1;
1209         SidsBuffer[i].Flags = 0;
1210     }
1211
1212     DomainsBuffer = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
1213     if (DomainsBuffer == NULL)
1214     {
1215         MIDL_user_free(SidsBuffer);
1216         return STATUS_INSUFFICIENT_RESOURCES;
1217     }
1218
1219     DomainsBuffer->Entries = Count;
1220     DomainsBuffer->Domains = MIDL_user_allocate(Count * sizeof(LSA_TRUST_INFORMATION));
1221     if (DomainsBuffer->Domains == NULL)
1222     {
1223         MIDL_user_free(DomainsBuffer);
1224         MIDL_user_free(SidsBuffer);
1225         return STATUS_INSUFFICIENT_RESOURCES;
1226     }
1227
1228     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
1229                                          2,
1230                                          SECURITY_BUILTIN_DOMAIN_RID,
1231                                          DOMAIN_ALIAS_RID_ADMINS,
1232                                          0, 0, 0, 0, 0, 0,
1233                                          &DomainSid);
1234     if (!NT_SUCCESS(Status))
1235     {
1236         MIDL_user_free(DomainsBuffer->Domains);
1237         MIDL_user_free(DomainsBuffer);
1238         MIDL_user_free(SidsBuffer);
1239         return Status;
1240     }
1241
1242     DomainSidLength = RtlLengthSid(DomainSid);
1243
1244     for (i = 0; i < Count; i++)
1245     {
1246         DomainsBuffer->Domains[i].Sid = MIDL_user_allocate(DomainSidLength);
1247         RtlCopyMemory(DomainsBuffer->Domains[i].Sid,
1248                       DomainSid,
1249                       DomainSidLength);
1250
1251         DomainsBuffer->Domains[i].Name.Buffer = MIDL_user_allocate(DomainName.MaximumLength);
1252         DomainsBuffer->Domains[i].Name.Length = DomainName.Length;
1253         DomainsBuffer->Domains[i].Name.MaximumLength = DomainName.MaximumLength;
1254         RtlCopyMemory(DomainsBuffer->Domains[i].Name.Buffer,
1255                       DomainName.Buffer,
1256                       DomainName.MaximumLength);
1257     }
1258
1259     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
1260                                          3,
1261                                          SECURITY_BUILTIN_DOMAIN_RID,
1262                                          DOMAIN_ALIAS_RID_ADMINS,
1263                                          DOMAIN_USER_RID_ADMIN,
1264                                          0, 0, 0, 0, 0,
1265                                          &AccountSid);
1266     if (!NT_SUCCESS(Status))
1267     {
1268         MIDL_user_free(DomainsBuffer->Domains);
1269         MIDL_user_free(DomainsBuffer);
1270         MIDL_user_free(SidsBuffer);
1271         return Status;
1272     }
1273
1274     AccountSidLength = RtlLengthSid(AccountSid);
1275
1276     for (i = 0; i < Count; i++)
1277     {
1278         SidsBuffer[i].Use = SidTypeWellKnownGroup;
1279         SidsBuffer[i].Sid = MIDL_user_allocate(AccountSidLength);
1280
1281         RtlCopyMemory(SidsBuffer[i].Sid,
1282                       AccountSid,
1283                       AccountSidLength);
1284
1285         SidsBuffer[i].DomainIndex = i;
1286         SidsBuffer[i].Flags = 0;
1287     }
1288
1289     *ReferencedDomains = DomainsBuffer;
1290     *MappedCount = Count;
1291
1292     TranslatedSids->Entries = Count;
1293     TranslatedSids->Sids = SidsBuffer;
1294
1295     return STATUS_SUCCESS;
1296 }
1297
1298
1299 /* Function 69 */
1300 NTSTATUS WINAPI CredrGetSessionTypes(
1301     handle_t hBinding)
1302 {
1303     UNIMPLEMENTED;
1304     return STATUS_NOT_IMPLEMENTED;
1305 }
1306
1307
1308 /* Function 70 */
1309 NTSTATUS WINAPI LsarRegisterAuditEvent(
1310     handle_t hBinding)
1311 {
1312     UNIMPLEMENTED;
1313     return STATUS_NOT_IMPLEMENTED;
1314 }
1315
1316
1317 /* Function 71 */
1318 NTSTATUS WINAPI LsarGenAuditEvent(
1319     handle_t hBinding)
1320 {
1321     UNIMPLEMENTED;
1322     return STATUS_NOT_IMPLEMENTED;
1323 }
1324
1325
1326 /* Function 72 */
1327 NTSTATUS WINAPI LsarUnregisterAuditEvent(
1328     handle_t hBinding)
1329 {
1330     UNIMPLEMENTED;
1331     return STATUS_NOT_IMPLEMENTED;
1332 }
1333
1334
1335 /* Function 73 */
1336 NTSTATUS WINAPI LsarQueryForestTrustInformation(
1337     LSAPR_HANDLE PolicyHandle,
1338     PLSA_UNICODE_STRING TrustedDomainName,
1339     LSA_FOREST_TRUST_RECORD_TYPE HighestRecordType,
1340     PLSA_FOREST_TRUST_INFORMATION *ForestTrustInfo)
1341 {
1342     UNIMPLEMENTED;
1343     return STATUS_NOT_IMPLEMENTED;
1344 }
1345
1346
1347 /* Function 74 */
1348 NTSTATUS WINAPI LsarSetForestTrustInformation(
1349     LSAPR_HANDLE PolicyHandle,
1350     PLSA_UNICODE_STRING TrustedDomainName,
1351     LSA_FOREST_TRUST_RECORD_TYPE HighestRecordType,
1352     PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
1353     BOOL CheckOnly,
1354     PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
1355 {
1356     UNIMPLEMENTED;
1357     return STATUS_NOT_IMPLEMENTED;
1358 }
1359
1360
1361 /* Function 75 */
1362 NTSTATUS WINAPI CredrRename(
1363     handle_t hBinding)
1364 {
1365     UNIMPLEMENTED;
1366     return STATUS_NOT_IMPLEMENTED;
1367 }
1368
1369
1370 /* Function 76 */
1371 NTSTATUS WINAPI LsarLookupSids3(
1372     LSAPR_HANDLE PolicyHandle,
1373     PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
1374     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1375     PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,
1376     LSAP_LOOKUP_LEVEL LookupLevel,
1377     DWORD *MappedCount,
1378     DWORD LookupOptions,
1379     DWORD ClientRevision)
1380 {
1381     UNIMPLEMENTED;
1382     return STATUS_NOT_IMPLEMENTED;
1383 }
1384
1385
1386 /* Function 77 */
1387 NTSTATUS WINAPI LsarLookupNames4(
1388     handle_t RpcHandle,
1389     DWORD Count,
1390     PRPC_UNICODE_STRING Names,
1391     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1392     PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,
1393     LSAP_LOOKUP_LEVEL LookupLevel,
1394     DWORD *MappedCount,
1395     DWORD LookupOptions,
1396     DWORD ClientRevision)
1397 {
1398     UNIMPLEMENTED;
1399     return STATUS_NOT_IMPLEMENTED;
1400 }
1401
1402
1403 /* Function 78 */
1404 NTSTATUS WINAPI LsarOpenPolicySce(
1405     handle_t hBinding)
1406 {
1407     UNIMPLEMENTED;
1408     return STATUS_NOT_IMPLEMENTED;
1409 }
1410
1411
1412 /* Function 79 */
1413 NTSTATUS WINAPI LsarAdtRegisterSecurityEventSource(
1414     handle_t hBinding)
1415 {
1416     UNIMPLEMENTED;
1417     return STATUS_NOT_IMPLEMENTED;
1418 }
1419
1420
1421 /* Function 80 */
1422 NTSTATUS WINAPI LsarAdtUnregisterSecurityEventSource(
1423     handle_t hBinding)
1424 {
1425     UNIMPLEMENTED;
1426     return STATUS_NOT_IMPLEMENTED;
1427 }
1428
1429
1430 /* Function 81 */
1431 NTSTATUS WINAPI LsarAdtReportSecurityEvent(
1432     handle_t hBinding)
1433 {
1434     UNIMPLEMENTED;
1435     return STATUS_NOT_IMPLEMENTED;
1436 }
1437
1438
1439 /* Function 82 */
1440 NTSTATUS WINAPI CredrFindBestCredential(
1441     handle_t hBinding)
1442 {
1443     UNIMPLEMENTED;
1444     return STATUS_NOT_IMPLEMENTED;
1445 }
1446
1447
1448 /* Function 83 */
1449 NTSTATUS WINAPI LsarSetAuditPolicy(
1450     handle_t hBinding)
1451 {
1452     UNIMPLEMENTED;
1453     return STATUS_NOT_IMPLEMENTED;
1454 }
1455
1456
1457 /* Function 84 */
1458 NTSTATUS WINAPI LsarQueryAuditPolicy(
1459     handle_t hBinding)
1460 {
1461     UNIMPLEMENTED;
1462     return STATUS_NOT_IMPLEMENTED;
1463 }
1464
1465
1466 /* Function 85 */
1467 NTSTATUS WINAPI LsarEnumerateAuditPolicy(
1468     handle_t hBinding)
1469 {
1470     UNIMPLEMENTED;
1471     return STATUS_NOT_IMPLEMENTED;
1472 }
1473
1474
1475 /* Function 86 */
1476 NTSTATUS WINAPI LsarEnumerateAuditCategories(
1477     handle_t hBinding)
1478 {
1479     UNIMPLEMENTED;
1480     return STATUS_NOT_IMPLEMENTED;
1481 }
1482
1483
1484 /* Function 87 */
1485 NTSTATUS WINAPI LsarEnumerateAuditSubCategories(
1486     handle_t hBinding)
1487 {
1488     UNIMPLEMENTED;
1489     return STATUS_NOT_IMPLEMENTED;
1490 }
1491
1492
1493 /* Function 88 */
1494 NTSTATUS WINAPI LsarLookupAuditCategoryName(
1495     handle_t hBinding)
1496 {
1497     UNIMPLEMENTED;
1498     return STATUS_NOT_IMPLEMENTED;
1499 }
1500
1501
1502 /* Function 89 */
1503 NTSTATUS WINAPI LsarLookupAuditSubCategoryName(
1504     handle_t hBinding)
1505 {
1506     UNIMPLEMENTED;
1507     return STATUS_NOT_IMPLEMENTED;
1508 }
1509
1510
1511 /* Function 90 */
1512 NTSTATUS WINAPI LsarSetAuditSecurity(
1513     handle_t hBinding)
1514 {
1515     UNIMPLEMENTED;
1516     return STATUS_NOT_IMPLEMENTED;
1517 }
1518
1519
1520 /* Function 91 */
1521 NTSTATUS WINAPI LsarQueryAuditSecurity(
1522     handle_t hBinding)
1523 {
1524     UNIMPLEMENTED;
1525     return STATUS_NOT_IMPLEMENTED;
1526 }
1527
1528
1529 /* Function 92 */
1530 NTSTATUS WINAPI CredReadByTokenHandle(
1531     handle_t hBinding)
1532 {
1533     UNIMPLEMENTED;
1534     return STATUS_NOT_IMPLEMENTED;
1535 }
1536
1537
1538 /* Function 93 */
1539 NTSTATUS WINAPI CredrRestoreCredentials(
1540     handle_t hBinding)
1541 {
1542     UNIMPLEMENTED;
1543     return STATUS_NOT_IMPLEMENTED;
1544 }
1545
1546
1547 /* Function 94 */
1548 NTSTATUS WINAPI CredrBackupCredentials(
1549     handle_t hBinding)
1550 {
1551     UNIMPLEMENTED;
1552     return STATUS_NOT_IMPLEMENTED;
1553 }
1554
1555 /* EOF */