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