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 WINE_DEFAULT_DEBUG_CHANNEL(lsasrv);
  15
  16
  17 /* GLOBALS *****************************************************************/
  18
  19 static RTL_CRITICAL_SECTION PolicyHandleTableLock;
  20
  21
  22 /* FUNCTIONS ***************************************************************/
  23
  24 VOID
  25 LsarStartRpcServer(VOID)
  26 {
  27     RPC_STATUS Status;
  28
  29     RtlInitializeCriticalSection(&PolicyHandleTableLock);
  30
  31     TRACE("LsarStartRpcServer() called\n");
  32
  33     Status = RpcServerUseProtseqEpW(L"ncacn_np",
  34                                     10,
  35                                     L"\\pipe\\lsarpc",
  36                                     NULL);
  37     if (Status != RPC_S_OK)
  38     {
  39         WARN("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
  40         return;
  41     }
  42
  43     Status = RpcServerRegisterIf(lsarpc_v0_0_s_ifspec,
  44                                  NULL,
  45                                  NULL);
  46     if (Status != RPC_S_OK)
  47     {
  48         WARN("RpcServerRegisterIf() failed (Status %lx)\n", Status);
  49         return;
  50     }
  51
  52     Status = RpcServerListen(1, 20, TRUE);
  53     if (Status != RPC_S_OK)
  54     {
  55         WARN("RpcServerListen() failed (Status %lx)\n", Status);
  56         return;
  57     }
  58
  59     TRACE("LsarStartRpcServer() done\n");
  60 }
  61
  62
  63 void __RPC_USER LSAPR_HANDLE_rundown(LSAPR_HANDLE hHandle)
  64 {
  65
  66 }
  67
  68
  69 /* Function 0 */
  70 NTSTATUS WINAPI LsarClose(
  71     LSAPR_HANDLE *ObjectHandle)
  72 {
  73     PLSA_DB_OBJECT DbObject;
  74     NTSTATUS Status = STATUS_SUCCESS;
  75
  76     TRACE("0x%p\n", ObjectHandle);
  77
  78 //    RtlEnterCriticalSection(&PolicyHandleTableLock);
  79
  80     Status = LsapValidateDbObject(*ObjectHandle,
  81                                   LsaDbIgnoreObject,
  82                                   0,
  83                                   &DbObject);
  84     if (Status == STATUS_SUCCESS)
  85     {
  86         Status = LsapCloseDbObject(DbObject);
  87         *ObjectHandle = NULL;
  88     }
  89
  90 //    RtlLeaveCriticalSection(&PolicyHandleTableLock);
  91
  92     return Status;
  93 }
  94
  95
  96 /* Function 1 */
  97 NTSTATUS WINAPI LsarDelete(
  98     LSAPR_HANDLE ObjectHandle)
  99 {
 100     /* Deprecated */
 101     return STATUS_NOT_SUPPORTED;
 102 }
 103
 104
 105 /* Function 2 */
 106 NTSTATUS WINAPI LsarEnumeratePrivileges(
 107     LSAPR_HANDLE PolicyHandle,
 108     DWORD *EnumerationContext,
 109     PLSAPR_PRIVILEGE_ENUM_BUFFER EnumerationBuffer,
 110     DWORD PreferedMaximumLength)
 111 {
 112     UNIMPLEMENTED;
 113     return STATUS_NOT_IMPLEMENTED;
 114 }
 115
 116
 117 /* Function 3 */
 118 NTSTATUS WINAPI LsarQuerySecurityObject(
 119     LSAPR_HANDLE ObjectHandle,
 120     SECURITY_INFORMATION SecurityInformation,
 121     PLSAPR_SR_SECURITY_DESCRIPTOR *SecurityDescriptor)
 122 {
 123     UNIMPLEMENTED;
 124     return STATUS_NOT_IMPLEMENTED;
 125 }
 126
 127
 128 /* Function 4 */
 129 NTSTATUS WINAPI LsarSetSecurityObject(
 130     LSAPR_HANDLE ObjectHandle,
 131     SECURITY_INFORMATION SecurityInformation,
 132     PLSAPR_SR_SECURITY_DESCRIPTOR SecurityDescriptor)
 133 {
 134     UNIMPLEMENTED;
 135     return STATUS_NOT_IMPLEMENTED;
 136 }
 137
 138
 139 /* Function 5 */
 140 NTSTATUS WINAPI LsarChangePassword(
 141     handle_t IDL_handle,
 142     PRPC_UNICODE_STRING String1,
 143     PRPC_UNICODE_STRING String2,
 144     PRPC_UNICODE_STRING String3,
 145     PRPC_UNICODE_STRING String4,
 146     PRPC_UNICODE_STRING String5)
 147 {
 148     /* Deprecated */
 149     return STATUS_NOT_IMPLEMENTED;
 150 }
 151
 152
 153 /* Function 6 */
 154 NTSTATUS WINAPI LsarOpenPolicy(
 155     LPWSTR SystemName,
 156     PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,
 157     ACCESS_MASK DesiredAccess,
 158     LSAPR_HANDLE *PolicyHandle)
 159 {
 160     PLSA_DB_OBJECT PolicyObject;
 161     NTSTATUS Status;
 162
 163     TRACE("LsarOpenPolicy called!\n");
 164
 165     RtlEnterCriticalSection(&PolicyHandleTableLock);
 166
 167     Status = LsapOpenDbObject(NULL,
 168                               L"Policy",
 169                               LsaDbPolicyObject,
 170                               DesiredAccess,
 171                               &PolicyObject);
 172
 173     RtlLeaveCriticalSection(&PolicyHandleTableLock);
 174
 175     if (NT_SUCCESS(Status))
 176         *PolicyHandle = (LSAPR_HANDLE)PolicyObject;
 177
 178     TRACE("LsarOpenPolicy done!\n");
 179
 180     return Status;
 181 }
 182
 183
 184 /* Function 7 */
 185 NTSTATUS WINAPI LsarQueryInformationPolicy(
 186     LSAPR_HANDLE PolicyHandle,
 187     POLICY_INFORMATION_CLASS InformationClass,
 188     PLSAPR_POLICY_INFORMATION *PolicyInformation)
 189 {
 190     PLSA_DB_OBJECT DbObject;
 191     ACCESS_MASK DesiredAccess = 0;
 192     NTSTATUS Status;
 193
 194     TRACE("LsarQueryInformationPolicy(%p,0x%08x,%p)\n",
 195           PolicyHandle, InformationClass, PolicyInformation);
 196
 197     if (PolicyInformation)
 198     {
 199         TRACE("*PolicyInformation %p\n", *PolicyInformation);
 200     }
 201
 202     switch (InformationClass)
 203     {
 204         case PolicyAuditLogInformation:
 205         case PolicyAuditEventsInformation:
 206         case PolicyAuditFullQueryInformation:
 207             DesiredAccess = POLICY_VIEW_AUDIT_INFORMATION;
 208             break;
 209
 210         case PolicyPrimaryDomainInformation:
 211         case PolicyAccountDomainInformation:
 212         case PolicyLsaServerRoleInformation:
 213         case PolicyReplicaSourceInformation:
 214         case PolicyDefaultQuotaInformation:
 215         case PolicyDnsDomainInformation:
 216         case PolicyDnsDomainInformationInt:
 217         case PolicyLocalAccountDomainInformation:
 218             DesiredAccess = POLICY_VIEW_LOCAL_INFORMATION;
 219             break;
 220
 221         case PolicyPdAccountInformation:
 222             DesiredAccess = POLICY_GET_PRIVATE_INFORMATION;
 223             break;
 224
 225         case PolicyLastEntry:
 226         default:
 227             ERR("Invalid InformationClass!\n");
 228             return STATUS_INVALID_PARAMETER;
 229     }
 230
 231     Status = LsapValidateDbObject(PolicyHandle,
 232                                   LsaDbPolicyObject,
 233                                   DesiredAccess,
 234                                   &DbObject);
 235     if (!NT_SUCCESS(Status))
 236         return Status;
 237
 238     switch (InformationClass)
 239     {
 240         case PolicyAuditEventsInformation:   /* 2 */
 241             Status = LsarQueryAuditEvents(PolicyHandle,
 242                                           PolicyInformation);
 243             break;
 244
 245         case PolicyPrimaryDomainInformation: /* 3 */
 246             Status = LsarQueryPrimaryDomain(PolicyHandle,
 247                                             PolicyInformation);
 248             break;
 249
 250         case PolicyAccountDomainInformation: /* 5 */
 251             Status = LsarQueryAccountDomain(PolicyHandle,
 252                                             PolicyInformation);
 253             break;
 254
 255         case PolicyDefaultQuotaInformation: /* 8 */
 256             Status = LsarQueryDefaultQuota(PolicyHandle,
 257                                            PolicyInformation);
 258             break;
 259
 260         case PolicyDnsDomainInformation:     /* 12 (0xc) */
 261             Status = LsarQueryDnsDomain(PolicyHandle,
 262                                         PolicyInformation);
 263             break;
 264
 265         case PolicyAuditLogInformation:
 266         case PolicyPdAccountInformation:
 267         case PolicyLsaServerRoleInformation:
 268         case PolicyReplicaSourceInformation:
 269         case PolicyModificationInformation:
 270         case PolicyAuditFullSetInformation:
 271         case PolicyAuditFullQueryInformation:
 272         case PolicyDnsDomainInformationInt:
 273         case PolicyLocalAccountDomainInformation:
 274             FIXME("Information class not implemented\n");
 275             Status = STATUS_UNSUCCESSFUL;
 276             break;
 277
 278         case PolicyLastEntry:
 279         default:
 280             ERR("Invalid InformationClass!\n");
 281             Status = STATUS_INVALID_PARAMETER;
 282     }
 283
 284     return Status;
 285 }
 286
 287
 288 /* Function 8 */
 289 NTSTATUS WINAPI LsarSetInformationPolicy(
 290     LSAPR_HANDLE PolicyHandle,
 291     POLICY_INFORMATION_CLASS InformationClass,
 292     PLSAPR_POLICY_INFORMATION PolicyInformation)
 293 {
 294     PLSA_DB_OBJECT DbObject;
 295     ACCESS_MASK DesiredAccess = 0;
 296     NTSTATUS Status;
 297
 298     TRACE("LsarSetInformationPolicy(%p,0x%08x,%p)\n",
 299           PolicyHandle, InformationClass, PolicyInformation);
 300
 301     if (PolicyInformation)
 302     {
 303         TRACE("*PolicyInformation %p\n", *PolicyInformation);
 304     }
 305
 306     switch (InformationClass)
 307     {
 308         case PolicyAuditLogInformation:
 309         case PolicyAuditFullSetInformation:
 310             DesiredAccess = POLICY_AUDIT_LOG_ADMIN;
 311             break;
 312
 313         case PolicyAuditEventsInformation:
 314             DesiredAccess = POLICY_SET_AUDIT_REQUIREMENTS;
 315             break;
 316
 317         case PolicyPrimaryDomainInformation:
 318         case PolicyAccountDomainInformation:
 319             DesiredAccess = POLICY_TRUST_ADMIN;
 320             break;
 321
 322         case PolicyLsaServerRoleInformation:
 323         case PolicyReplicaSourceInformation:
 324             DesiredAccess = POLICY_SERVER_ADMIN;
 325             break;
 326
 327         case PolicyDefaultQuotaInformation:
 328             DesiredAccess = POLICY_SET_DEFAULT_QUOTA_LIMITS;
 329             break;
 330
 331         default:
 332             ERR("Invalid InformationClass!\n");
 333             return STATUS_INVALID_PARAMETER;
 334     }
 335
 336     Status = LsapValidateDbObject(PolicyHandle,
 337                                   LsaDbPolicyObject,
 338                                   DesiredAccess,
 339                                   &DbObject);
 340     if (!NT_SUCCESS(Status))
 341         return Status;
 342
 343     switch (InformationClass)
 344     {
 345         case PolicyAuditEventsInformation:
 346             Status = STATUS_NOT_IMPLEMENTED;
 347             break;
 348
 349         case PolicyPrimaryDomainInformation:
 350             Status = LsarSetPrimaryDomain(PolicyHandle,
 351                                           (PLSAPR_POLICY_PRIMARY_DOM_INFO)PolicyInformation);
 352             break;
 353
 354         case PolicyAccountDomainInformation:
 355             Status = LsarSetAccountDomain(PolicyHandle,
 356                                           (PLSAPR_POLICY_ACCOUNT_DOM_INFO)PolicyInformation);
 357             break;
 358
 359         case PolicyDnsDomainInformation:
 360             Status = LsarSetDnsDomain(PolicyHandle,
 361                                       (PLSAPR_POLICY_DNS_DOMAIN_INFO)PolicyInformation);
 362             break;
 363
 364         case PolicyLsaServerRoleInformation:
 365             Status = STATUS_NOT_IMPLEMENTED;
 366             break;
 367
 368         default:
 369             Status = STATUS_INVALID_PARAMETER;
 370             break;
 371     }
 372
 373     return Status;
 374 }
 375
 376
 377 /* Function 9 */
 378 NTSTATUS WINAPI LsarClearAuditLog(
 379     LSAPR_HANDLE ObjectHandle)
 380 {
 381     /* Deprecated */
 382     return STATUS_NOT_IMPLEMENTED;
 383 }
 384
 385
 386 /* Function 10 */
 387 NTSTATUS WINAPI LsarCreateAccount(
 388     LSAPR_HANDLE PolicyHandle,
 389     PRPC_SID AccountSid,
 390     ACCESS_MASK DesiredAccess,
 391     LSAPR_HANDLE *AccountHandle)
 392 {
 393     PLSA_DB_OBJECT PolicyObject;
 394     PLSA_DB_OBJECT AccountsObject = NULL;
 395     PLSA_DB_OBJECT AccountObject = NULL;
 396     LPWSTR SidString = NULL;
 397     NTSTATUS Status = STATUS_SUCCESS;
 398
 399     /* Validate the PolicyHandle */
 400     Status = LsapValidateDbObject(PolicyHandle,
 401                                   LsaDbPolicyObject,
 402                                   POLICY_CREATE_ACCOUNT,
 403                                   &PolicyObject);
 404     if (!NT_SUCCESS(Status))
 405     {
 406         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
 407         return Status;
 408     }
 409
 410     /* Open the Accounts object */
 411     Status = LsapOpenDbObject(PolicyObject,
 412                               L"Accounts",
 413                               LsaDbContainerObject,
 414                               0,
 415                               &AccountsObject);
 416     if (!NT_SUCCESS(Status))
 417     {
 418         ERR("LsapCreateDbObject (Accounts) failed (Status 0x%08lx)\n", Status);
 419         goto done;
 420     }
 421
 422     /* Create SID string */
 423     if (!ConvertSidToStringSid((PSID)AccountSid,
 424                                &SidString))
 425     {
 426         ERR("ConvertSidToStringSid failed\n");
 427         Status = STATUS_INVALID_PARAMETER;
 428         goto done;
 429     }
 430
 431     /* Create the Account object */
 432     Status = LsapCreateDbObject(AccountsObject,
 433                                 SidString,
 434                                 LsaDbAccountObject,
 435                                 DesiredAccess,
 436                                 &AccountObject);
 437     if (!NT_SUCCESS(Status))
 438     {
 439         ERR("LsapCreateDbObject (Account) failed (Status 0x%08lx)\n", Status);
 440         goto done;
 441     }
 442
 443     /* Set the Sid attribute */
 444     Status = LsapSetObjectAttribute(AccountObject,
 445                                     L"Sid",
 446                                     (PVOID)AccountSid,
 447                                     GetLengthSid(AccountSid));
 448
 449 done:
 450     if (SidString != NULL)
 451         LocalFree(SidString);
 452
 453     if (!NT_SUCCESS(Status))
 454     {
 455         if (AccountObject != NULL)
 456             LsapCloseDbObject(AccountObject);
 457     }
 458     else
 459     {
 460         *AccountHandle = (LSAPR_HANDLE)AccountObject;
 461     }
 462
 463     if (AccountsObject != NULL)
 464         LsapCloseDbObject(AccountsObject);
 465
 466     return STATUS_SUCCESS;
 467 }
 468
 469
 470 /* Function 11 */
 471 NTSTATUS WINAPI LsarEnumerateAccounts(
 472     LSAPR_HANDLE PolicyHandle,
 473     DWORD *EnumerationContext,
 474     PLSAPR_ACCOUNT_ENUM_BUFFER EnumerationBuffer,
 475     DWORD PreferedMaximumLength)
 476 {
 477     UNIMPLEMENTED;
 478     return STATUS_NOT_IMPLEMENTED;
 479 }
 480
 481
 482 /* Function 12 */
 483 NTSTATUS WINAPI LsarCreateTrustedDomain(
 484     LSAPR_HANDLE PolicyHandle,
 485     PLSAPR_TRUST_INFORMATION TrustedDomainInformation,
 486     ACCESS_MASK DesiredAccess,
 487     LSAPR_HANDLE *TrustedDomainHandle)
 488 {
 489     UNIMPLEMENTED;
 490     return STATUS_NOT_IMPLEMENTED;
 491 }
 492
 493
 494 /* Function 13 */
 495 NTSTATUS WINAPI LsarEnumerateTrustedDomains(
 496     LSAPR_HANDLE PolicyHandle,
 497     DWORD *EnumerationContext,
 498     PLSAPR_TRUSTED_ENUM_BUFFER EnumerationBuffer,
 499     DWORD PreferedMaximumLength)
 500 {
 501     UNIMPLEMENTED;
 502     return STATUS_NOT_IMPLEMENTED;
 503 }
 504
 505
 506 /* Function 14 */
 507 NTSTATUS WINAPI LsarLookupNames(
 508     LSAPR_HANDLE PolicyHandle,
 509     DWORD Count,
 510     PRPC_UNICODE_STRING Names,
 511     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 512     PLSAPR_TRANSLATED_SIDS TranslatedSids,
 513     LSAP_LOOKUP_LEVEL LookupLevel,
 514     DWORD *MappedCount)
 515 {
 516     SID_IDENTIFIER_AUTHORITY IdentifierAuthority = {SECURITY_NT_AUTHORITY};
 517     static const UNICODE_STRING DomainName = RTL_CONSTANT_STRING(L"DOMAIN");
 518     PLSAPR_REFERENCED_DOMAIN_LIST OutputDomains = NULL;
 519     PLSA_TRANSLATED_SID OutputSids = NULL;
 520     ULONG OutputSidsLength;
 521     ULONG i;
 522     PSID Sid;
 523     ULONG SidLength;
 524     NTSTATUS Status;
 525
 526     TRACE("LsarLookupNames(%p, %lu, %p, %p, %p, %d, %p)\n",
 527           PolicyHandle, Count, Names, ReferencedDomains, TranslatedSids,
 528           LookupLevel, MappedCount);
 529
 530     TranslatedSids->Entries = Count;
 531     TranslatedSids->Sids = NULL;
 532     *ReferencedDomains = NULL;
 533
 534     OutputSidsLength = Count * sizeof(LSA_TRANSLATED_SID);
 535     OutputSids = MIDL_user_allocate(OutputSidsLength);
 536     if (OutputSids == NULL)
 537     {
 538         return STATUS_INSUFFICIENT_RESOURCES;
 539     }
 540
 541     RtlZeroMemory(OutputSids, OutputSidsLength);
 542
 543     OutputDomains = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
 544     if (OutputDomains == NULL)
 545     {
 546         MIDL_user_free(OutputSids);
 547         return STATUS_INSUFFICIENT_RESOURCES;
 548     }
 549
 550     OutputDomains->Entries = Count;
 551     OutputDomains->Domains = MIDL_user_allocate(Count * sizeof(LSA_TRUST_INFORMATION));
 552     if (OutputDomains->Domains == NULL)
 553     {
 554         MIDL_user_free(OutputDomains);
 555         MIDL_user_free(OutputSids);
 556         return STATUS_INSUFFICIENT_RESOURCES;
 557     }
 558
 559     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
 560                                          2,
 561                                          SECURITY_BUILTIN_DOMAIN_RID,
 562                                          DOMAIN_ALIAS_RID_ADMINS,
 563                                          0, 0, 0, 0, 0, 0,
 564                                          &Sid);
 565     if (!NT_SUCCESS(Status))
 566     {
 567         MIDL_user_free(OutputDomains->Domains);
 568         MIDL_user_free(OutputDomains);
 569         MIDL_user_free(OutputSids);
 570         return Status;
 571     }
 572
 573     SidLength = RtlLengthSid(Sid);
 574
 575     for (i = 0; i < Count; i++)
 576     {
 577         OutputDomains->Domains[i].Sid = MIDL_user_allocate(SidLength);
 578         RtlCopyMemory(OutputDomains->Domains[i].Sid, Sid, SidLength);
 579
 580         OutputDomains->Domains[i].Name.Buffer = MIDL_user_allocate(DomainName.MaximumLength);
 581         OutputDomains->Domains[i].Name.Length = DomainName.Length;
 582         OutputDomains->Domains[i].Name.MaximumLength = DomainName.MaximumLength;
 583         RtlCopyMemory(OutputDomains->Domains[i].Name.Buffer, DomainName.Buffer, DomainName.MaximumLength);
 584     }
 585
 586     for (i = 0; i < Count; i++)
 587     {
 588         OutputSids[i].Use = SidTypeWellKnownGroup;
 589         OutputSids[i].RelativeId = DOMAIN_USER_RID_ADMIN; //DOMAIN_ALIAS_RID_ADMINS;
 590         OutputSids[i].DomainIndex = i;
 591     }
 592
 593     *ReferencedDomains = OutputDomains;
 594
 595     *MappedCount = Count;
 596
 597     TranslatedSids->Entries = Count;
 598     TranslatedSids->Sids = OutputSids;
 599
 600     return STATUS_SUCCESS;
 601 }
 602
 603
 604 /* Function 15 */
 605 NTSTATUS WINAPI LsarLookupSids(
 606     LSAPR_HANDLE PolicyHandle,
 607     PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
 608     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 609     PLSAPR_TRANSLATED_NAMES TranslatedNames,
 610     LSAP_LOOKUP_LEVEL LookupLevel,
 611     DWORD *MappedCount)
 612 {
 613     SID_IDENTIFIER_AUTHORITY IdentifierAuthority = {SECURITY_NT_AUTHORITY};
 614     static const UNICODE_STRING DomainName = RTL_CONSTANT_STRING(L"DOMAIN");
 615     PLSAPR_REFERENCED_DOMAIN_LIST OutputDomains = NULL;
 616     PLSAPR_TRANSLATED_NAME OutputNames = NULL;
 617     ULONG OutputNamesLength;
 618     ULONG i;
 619     PSID Sid;
 620     ULONG SidLength;
 621     NTSTATUS Status;
 622
 623     TRACE("LsarLookupSids(%p, %p, %p, %p, %d, %p)\n",
 624           PolicyHandle, SidEnumBuffer, ReferencedDomains, TranslatedNames,
 625           LookupLevel, MappedCount);
 626
 627     TranslatedNames->Entries = SidEnumBuffer->Entries;
 628     TranslatedNames->Names = NULL;
 629     *ReferencedDomains = NULL;
 630
 631     OutputNamesLength = SidEnumBuffer->Entries * sizeof(LSA_TRANSLATED_NAME);
 632     OutputNames = MIDL_user_allocate(OutputNamesLength);
 633     if (OutputNames == NULL)
 634     {
 635         return STATUS_INSUFFICIENT_RESOURCES;
 636     }
 637
 638     RtlZeroMemory(OutputNames, OutputNamesLength);
 639
 640     OutputDomains = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
 641     if (OutputDomains == NULL)
 642     {
 643         MIDL_user_free(OutputNames);
 644         return STATUS_INSUFFICIENT_RESOURCES;
 645     }
 646
 647     OutputDomains->Entries = SidEnumBuffer->Entries;
 648     OutputDomains->Domains = MIDL_user_allocate(SidEnumBuffer->Entries * sizeof(LSA_TRUST_INFORMATION));
 649     if (OutputDomains->Domains == NULL)
 650     {
 651         MIDL_user_free(OutputDomains);
 652         MIDL_user_free(OutputNames);
 653         return STATUS_INSUFFICIENT_RESOURCES;
 654     }
 655
 656     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
 657                                          2,
 658                                          SECURITY_BUILTIN_DOMAIN_RID,
 659                                          DOMAIN_ALIAS_RID_ADMINS,
 660                                          0, 0, 0, 0, 0, 0,
 661                                          &Sid);
 662     if (!NT_SUCCESS(Status))
 663     {
 664         MIDL_user_free(OutputDomains->Domains);
 665         MIDL_user_free(OutputDomains);
 666         MIDL_user_free(OutputNames);
 667         return Status;
 668     }
 669
 670     SidLength = RtlLengthSid(Sid);
 671
 672     for (i = 0; i < SidEnumBuffer->Entries; i++)
 673     {
 674         OutputDomains->Domains[i].Sid = MIDL_user_allocate(SidLength);
 675         RtlCopyMemory(OutputDomains->Domains[i].Sid, Sid, SidLength);
 676
 677         OutputDomains->Domains[i].Name.Buffer = MIDL_user_allocate(DomainName.MaximumLength);
 678         OutputDomains->Domains[i].Name.Length = DomainName.Length;
 679         OutputDomains->Domains[i].Name.MaximumLength = DomainName.MaximumLength;
 680         RtlCopyMemory(OutputDomains->Domains[i].Name.Buffer, DomainName.Buffer, DomainName.MaximumLength);
 681     }
 682
 683     Status = LsapLookupSids(SidEnumBuffer,
 684                             OutputNames);
 685
 686     *ReferencedDomains = OutputDomains;
 687
 688     *MappedCount = SidEnumBuffer->Entries;
 689
 690     TranslatedNames->Entries = SidEnumBuffer->Entries;
 691     TranslatedNames->Names = OutputNames;
 692
 693     return Status;
 694 }
 695
 696
 697 /* Function 16 */
 698 NTSTATUS WINAPI LsarCreateSecret(
 699     LSAPR_HANDLE PolicyHandle,
 700     PRPC_UNICODE_STRING SecretName,
 701     ACCESS_MASK DesiredAccess,
 702     LSAPR_HANDLE *SecretHandle)
 703 {
 704     PLSA_DB_OBJECT PolicyObject;
 705     PLSA_DB_OBJECT SecretsObject = NULL;
 706     PLSA_DB_OBJECT SecretObject = NULL;
 707     LARGE_INTEGER Time;
 708     NTSTATUS Status = STATUS_SUCCESS;
 709
 710     /* Validate the PolicyHandle */
 711     Status = LsapValidateDbObject(PolicyHandle,
 712                                   LsaDbPolicyObject,
 713                                   POLICY_CREATE_SECRET,
 714                                   &PolicyObject);
 715     if (!NT_SUCCESS(Status))
 716     {
 717         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
 718         return Status;
 719     }
 720
 721     /* Open the Secrets object */
 722     Status = LsapOpenDbObject(PolicyObject,
 723                               L"Secrets",
 724                               LsaDbContainerObject,
 725                               0,
 726                               &SecretsObject);
 727     if (!NT_SUCCESS(Status))
 728     {
 729         ERR("LsapCreateDbObject (Secrets) failed (Status 0x%08lx)\n", Status);
 730         goto done;
 731     }
 732
 733     /* Get the current time */
 734     Status = NtQuerySystemTime(&Time);
 735     if (!NT_SUCCESS(Status))
 736     {
 737         ERR("NtQuerySystemTime failed (Status 0x%08lx)\n", Status);
 738         goto done;
 739     }
 740
 741     /* Create the Secret object */
 742     Status = LsapCreateDbObject(SecretsObject,
 743                                 SecretName->Buffer,
 744                                 LsaDbSecretObject,
 745                                 DesiredAccess,
 746                                 &SecretObject);
 747     if (!NT_SUCCESS(Status))
 748     {
 749         ERR("LsapCreateDbObject (Secret) failed (Status 0x%08lx)\n", Status);
 750         goto done;
 751     }
 752
 753     /* Set the CurrentTime attribute */
 754     Status = LsapSetObjectAttribute(SecretObject,
 755                                     L"CurrentTime",
 756                                     (PVOID)&Time,
 757                                     sizeof(LARGE_INTEGER));
 758     if (!NT_SUCCESS(Status))
 759     {
 760         ERR("LsapSetObjectAttribute (CurrentTime) failed (Status 0x%08lx)\n", Status);
 761         goto done;
 762     }
 763
 764     /* Set the OldTime attribute */
 765     Status = LsapSetObjectAttribute(SecretObject,
 766                                     L"OldTime",
 767                                     (PVOID)&Time,
 768                                     sizeof(LARGE_INTEGER));
 769
 770 done:
 771     if (!NT_SUCCESS(Status))
 772     {
 773         if (SecretObject != NULL)
 774             LsapCloseDbObject(SecretObject);
 775     }
 776     else
 777     {
 778         *SecretHandle = (LSAPR_HANDLE)SecretObject;
 779     }
 780
 781     if (SecretsObject != NULL)
 782         LsapCloseDbObject(SecretsObject);
 783
 784     return STATUS_SUCCESS;
 785 }
 786
 787
 788 /* Function 17 */
 789 NTSTATUS WINAPI LsarOpenAccount(
 790     LSAPR_HANDLE PolicyHandle,
 791     PRPC_SID AccountSid,
 792     ACCESS_MASK DesiredAccess,
 793     LSAPR_HANDLE *AccountHandle)
 794 {
 795     PLSA_DB_OBJECT PolicyObject;
 796     PLSA_DB_OBJECT AccountsObject = NULL;
 797     PLSA_DB_OBJECT AccountObject = NULL;
 798     LPWSTR SidString = NULL;
 799     NTSTATUS Status = STATUS_SUCCESS;
 800
 801     /* Validate the PolicyHandle */
 802     Status = LsapValidateDbObject(PolicyHandle,
 803                                   LsaDbPolicyObject,
 804                                   POLICY_CREATE_ACCOUNT,
 805                                   &PolicyObject);
 806     if (!NT_SUCCESS(Status))
 807     {
 808         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
 809         return Status;
 810     }
 811
 812     /* Open the Accounts object */
 813     Status = LsapOpenDbObject(PolicyObject,
 814                               L"Accounts",
 815                               LsaDbContainerObject,
 816                               0,
 817                               &AccountsObject);
 818     if (!NT_SUCCESS(Status))
 819     {
 820         ERR("LsapCreateDbObject (Accounts) failed (Status 0x%08lx)\n", Status);
 821         goto done;
 822     }
 823
 824     /* Create SID string */
 825     if (!ConvertSidToStringSid((PSID)AccountSid,
 826                                &SidString))
 827     {
 828         ERR("ConvertSidToStringSid failed\n");
 829         Status = STATUS_INVALID_PARAMETER;
 830         goto done;
 831     }
 832
 833     /* Create the Account object */
 834     Status = LsapOpenDbObject(AccountsObject,
 835                               SidString,
 836                               LsaDbAccountObject,
 837                               DesiredAccess,
 838                               &AccountObject);
 839     if (!NT_SUCCESS(Status))
 840     {
 841         ERR("LsapOpenDbObject (Account) failed (Status 0x%08lx)\n", Status);
 842         goto done;
 843     }
 844
 845     /* Set the Sid attribute */
 846     Status = LsapSetObjectAttribute(AccountObject,
 847                                     L"Sid",
 848                                     (PVOID)AccountSid,
 849                                     GetLengthSid(AccountSid));
 850
 851 done:
 852     if (SidString != NULL)
 853         LocalFree(SidString);
 854
 855     if (!NT_SUCCESS(Status))
 856     {
 857         if (AccountObject != NULL)
 858             LsapCloseDbObject(AccountObject);
 859     }
 860     else
 861     {
 862         *AccountHandle = (LSAPR_HANDLE)AccountObject;
 863     }
 864
 865     if (AccountsObject != NULL)
 866         LsapCloseDbObject(AccountsObject);
 867
 868     return STATUS_SUCCESS;
 869 }
 870
 871
 872 /* Function 18 */
 873 NTSTATUS WINAPI LsarEnumeratePrivilegesAccount(
 874     LSAPR_HANDLE AccountHandle,
 875     PLSAPR_PRIVILEGE_SET *Privileges)
 876 {
 877     PLSA_DB_OBJECT AccountObject;
 878     ULONG PrivilegeSetSize = 0;
 879     PLSAPR_PRIVILEGE_SET PrivilegeSet = NULL;
 880     NTSTATUS Status;
 881
 882     *Privileges = NULL;
 883
 884     /* Validate the AccountHandle */
 885     Status = LsapValidateDbObject(AccountHandle,
 886                                   LsaDbAccountObject,
 887                                   ACCOUNT_VIEW,
 888                                   &AccountObject);
 889     if (!NT_SUCCESS(Status))
 890     {
 891         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
 892         return Status;
 893     }
 894
 895     /* Get the size of the privilege set */
 896     Status = LsapGetObjectAttribute(AccountObject,
 897                                     L"Privilgs",
 898                                     NULL,
 899                                     &PrivilegeSetSize);
 900     if (!NT_SUCCESS(Status))
 901         return Status;
 902
 903     /* Allocate a buffer for the privilege set */
 904     PrivilegeSet = MIDL_user_allocate(PrivilegeSetSize);
 905     if (PrivilegeSet == NULL)
 906         return STATUS_NO_MEMORY;
 907
 908     /* Get the privilege set */
 909     Status = LsapGetObjectAttribute(AccountObject,
 910                                     L"Privilgs",
 911                                     PrivilegeSet,
 912                                     &PrivilegeSetSize);
 913     if (!NT_SUCCESS(Status))
 914     {
 915         MIDL_user_free(PrivilegeSet);
 916         return Status;
 917     }
 918
 919     /* Return a pointer to the privilege set */
 920     *Privileges = PrivilegeSet;
 921
 922     return STATUS_SUCCESS;
 923 }
 924
 925
 926 /* Function 19 */
 927 NTSTATUS WINAPI LsarAddPrivilegesToAccount(
 928     LSAPR_HANDLE AccountHandle,
 929     PLSAPR_PRIVILEGE_SET Privileges)
 930 {
 931     PLSA_DB_OBJECT AccountObject;
 932     PPRIVILEGE_SET CurrentPrivileges = NULL;
 933     PPRIVILEGE_SET NewPrivileges = NULL;
 934     ULONG PrivilegeSetSize = 0;
 935     ULONG PrivilegeCount;
 936     ULONG i, j;
 937     BOOL bFound;
 938     NTSTATUS Status;
 939
 940     /* Validate the AccountHandle */
 941     Status = LsapValidateDbObject(AccountHandle,
 942                                   LsaDbAccountObject,
 943                                   ACCOUNT_ADJUST_PRIVILEGES,
 944                                   &AccountObject);
 945     if (!NT_SUCCESS(Status))
 946     {
 947         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
 948         return Status;
 949     }
 950
 951     Status = LsapGetObjectAttribute(AccountObject,
 952                                     L"Privilgs",
 953                                     NULL,
 954                                     &PrivilegeSetSize);
 955     if (!NT_SUCCESS(Status) || PrivilegeSetSize == 0)
 956     {
 957         /* The Privilgs attribute does not exist */
 958
 959         PrivilegeSetSize = sizeof(PRIVILEGE_SET) +
 960                            (Privileges->PrivilegeCount - 1) * sizeof(LUID_AND_ATTRIBUTES);
 961         Status = LsapSetObjectAttribute(AccountObject,
 962                                         L"Privilgs",
 963                                         Privileges,
 964                                         PrivilegeSetSize);
 965     }
 966     else
 967     {
 968         /* The Privilgs attribute exists */
 969
 970         /* Allocate memory for the stored privilege set */
 971         CurrentPrivileges = MIDL_user_allocate(PrivilegeSetSize);
 972         if (CurrentPrivileges == NULL)
 973             return STATUS_NO_MEMORY;
 974
 975         /* Get the current privilege set */
 976         Status = LsapGetObjectAttribute(AccountObject,
 977                                         L"Privilgs",
 978                                         CurrentPrivileges,
 979                                         &PrivilegeSetSize);
 980         if (!NT_SUCCESS(Status))
 981         {
 982             TRACE("LsapGetObjectAttribute() failed (Status 0x%08lx)\n", Status);
 983             goto done;
 984         }
 985
 986         PrivilegeCount = CurrentPrivileges->PrivilegeCount;
 987         TRACE("Current privilege count: %lu\n", PrivilegeCount);
 988
 989         /* Calculate the number privileges in the combined privilege set */
 990         for (i = 0; i < Privileges->PrivilegeCount; i++)
 991         {
 992             bFound = FALSE;
 993             for (j = 0; j < CurrentPrivileges->PrivilegeCount; j++)
 994             {
 995                 if (RtlEqualLuid(&(Privileges->Privilege[i].Luid),
 996                                  &(CurrentPrivileges->Privilege[i].Luid)))
 997                 {
 998                     bFound = TRUE;
 999                     break;
1000                 }
1001             }
1002
1003             if (bFound == FALSE)
1004             {
1005                 TRACE("Found new privilege\n");
1006                 PrivilegeCount++;
1007             }
1008         }
1009         TRACE("New privilege count: %lu\n", PrivilegeCount);
1010
1011         /* Calculate the size of the new privilege set and allocate it */
1012         PrivilegeSetSize = sizeof(PRIVILEGE_SET) +
1013                            (PrivilegeCount - 1) * sizeof(LUID_AND_ATTRIBUTES);
1014         NewPrivileges = MIDL_user_allocate(PrivilegeSetSize);
1015         if (NewPrivileges == NULL)
1016         {
1017             Status = STATUS_NO_MEMORY;
1018             goto done;
1019         }
1020
1021         /* Initialize the new privilege set */
1022         NewPrivileges->PrivilegeCount = PrivilegeCount;
1023         NewPrivileges->Control = 0;
1024
1025         /* Copy all privileges from the current privilege set */
1026         RtlCopyLuidAndAttributesArray(CurrentPrivileges->PrivilegeCount,
1027                                       &(CurrentPrivileges->Privilege[0]),
1028                                       &(NewPrivileges->Privilege[0]));
1029
1030         /* Add new privileges to the new privilege set */
1031         PrivilegeCount = CurrentPrivileges->PrivilegeCount;
1032         for (i = 0; i < Privileges->PrivilegeCount; i++)
1033         {
1034             bFound = FALSE;
1035             for (j = 0; j < CurrentPrivileges->PrivilegeCount; j++)
1036             {
1037                 if (RtlEqualLuid(&(Privileges->Privilege[i].Luid),
1038                                  &(CurrentPrivileges->Privilege[i].Luid)))
1039                 {
1040                     /* Overwrite attributes if a matching privilege was found */
1041                     NewPrivileges->Privilege[j].Attributes = Privileges->Privilege[i].Attributes;
1042
1043                     bFound = TRUE;
1044                     break;
1045                 }
1046             }
1047
1048             if (bFound == FALSE)
1049             {
1050                 /* Copy the new privilege */
1051                 RtlCopyLuidAndAttributesArray(1,
1052                                               (PLUID_AND_ATTRIBUTES)&(Privileges->Privilege[i]),
1053                                               &(NewPrivileges->Privilege[PrivilegeCount]));
1054                 PrivilegeCount++;
1055             }
1056         }
1057
1058         /* Set the new priivliege set */
1059         Status = LsapSetObjectAttribute(AccountObject,
1060                                         L"Privilgs",
1061                                         NewPrivileges,
1062                                         PrivilegeSetSize);
1063     }
1064
1065 done:
1066     if (CurrentPrivileges != NULL)
1067         MIDL_user_free(CurrentPrivileges);
1068
1069     if (NewPrivileges != NULL)
1070         MIDL_user_free(NewPrivileges);
1071
1072     return Status;
1073 }
1074
1075
1076 /* Function 20 */
1077 NTSTATUS WINAPI LsarRemovePrivilegesFromAccount(
1078     LSAPR_HANDLE AccountHandle,
1079     BOOL AllPrivileges,
1080     PLSAPR_PRIVILEGE_SET Privileges)
1081 {
1082     UNIMPLEMENTED;
1083     return STATUS_NOT_IMPLEMENTED;
1084 }
1085
1086
1087 /* Function 21 */
1088 NTSTATUS WINAPI LsarGetQuotasForAccount(
1089     LSAPR_HANDLE AccountHandle,
1090     PQUOTA_LIMITS QuotaLimits)
1091 {
1092     UNIMPLEMENTED;
1093     return STATUS_NOT_IMPLEMENTED;
1094 }
1095
1096
1097 /* Function 22 */
1098 NTSTATUS WINAPI LsarSetQuotasForAccount(
1099     LSAPR_HANDLE AccountHandle,
1100     PQUOTA_LIMITS QuotaLimits)
1101 {
1102     UNIMPLEMENTED;
1103     return STATUS_NOT_IMPLEMENTED;
1104 }
1105
1106
1107 /* Function 23 */
1108 NTSTATUS WINAPI LsarGetSystemAccessAccount(
1109     LSAPR_HANDLE AccountHandle,
1110     ACCESS_MASK *SystemAccess)
1111 {
1112     PLSA_DB_OBJECT AccountObject;
1113     ULONG Size;
1114     NTSTATUS Status;
1115
1116     /* Validate the account handle */
1117     Status = LsapValidateDbObject(AccountHandle,
1118                                   LsaDbAccountObject,
1119                                   ACCOUNT_VIEW,
1120                                   &AccountObject);
1121     if (!NT_SUCCESS(Status))
1122     {
1123         ERR("Invalid handle (Status %lx)\n", Status);
1124         return Status;
1125     }
1126
1127     /* Get the system access flags */
1128     Status = LsapGetObjectAttribute(AccountObject,
1129                                     L"ActSysAc",
1130                                     SystemAccess,
1131                                     &Size);
1132
1133     return Status;
1134 }
1135
1136
1137 /* Function 24 */
1138 NTSTATUS WINAPI LsarSetSystemAccessAccount(
1139     LSAPR_HANDLE AccountHandle,
1140     ACCESS_MASK SystemAccess)
1141 {
1142     PLSA_DB_OBJECT AccountObject;
1143     NTSTATUS Status;
1144
1145     /* Validate the account handle */
1146     Status = LsapValidateDbObject(AccountHandle,
1147                                   LsaDbAccountObject,
1148                                   ACCOUNT_ADJUST_SYSTEM_ACCESS,
1149                                   &AccountObject);
1150     if (!NT_SUCCESS(Status))
1151     {
1152         ERR("Invalid handle (Status %lx)\n", Status);
1153         return Status;
1154     }
1155
1156     /* Set the system access flags */
1157     Status = LsapSetObjectAttribute(AccountObject,
1158                                     L"ActSysAc",
1159                                     &SystemAccess,
1160                                     sizeof(ACCESS_MASK));
1161
1162     return Status;
1163 }
1164
1165
1166 /* Function 25 */
1167 NTSTATUS WINAPI LsarOpenTrustedDomain(
1168     LSAPR_HANDLE PolicyHandle,
1169     PRPC_SID TrustedDomainSid,
1170     ACCESS_MASK DesiredAccess,
1171     LSAPR_HANDLE *TrustedDomainHandle)
1172 {
1173     UNIMPLEMENTED;
1174     return STATUS_NOT_IMPLEMENTED;
1175 }
1176
1177
1178 /* Function 26 */
1179 NTSTATUS WINAPI LsarQueryInfoTrustedDomain(
1180     LSAPR_HANDLE TrustedDomainHandle,
1181     TRUSTED_INFORMATION_CLASS InformationClass,
1182     PLSAPR_TRUSTED_DOMAIN_INFO *TrustedDomainInformation)
1183 {
1184     UNIMPLEMENTED;
1185     return STATUS_NOT_IMPLEMENTED;
1186 }
1187
1188
1189 /* Function 27 */
1190 NTSTATUS WINAPI LsarSetInformationTrustedDomain(
1191     LSAPR_HANDLE TrustedDomainHandle,
1192     TRUSTED_INFORMATION_CLASS InformationClass,
1193     PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation)
1194 {
1195     UNIMPLEMENTED;
1196     return STATUS_NOT_IMPLEMENTED;
1197 }
1198
1199
1200 /* Function 28 */
1201 NTSTATUS WINAPI LsarOpenSecret(
1202     LSAPR_HANDLE PolicyHandle,
1203     PRPC_UNICODE_STRING SecretName,
1204     ACCESS_MASK DesiredAccess,
1205     LSAPR_HANDLE *SecretHandle)
1206 {
1207     PLSA_DB_OBJECT PolicyObject;
1208     PLSA_DB_OBJECT SecretsObject = NULL;
1209     PLSA_DB_OBJECT SecretObject = NULL;
1210     NTSTATUS Status = STATUS_SUCCESS;
1211
1212     /* Validate the PolicyHandle */
1213     Status = LsapValidateDbObject(PolicyHandle,
1214                                   LsaDbPolicyObject,
1215                                   POLICY_CREATE_SECRET,
1216                                   &PolicyObject);
1217     if (!NT_SUCCESS(Status))
1218     {
1219         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
1220         return Status;
1221     }
1222
1223     /* Open the Secrets object */
1224     Status = LsapOpenDbObject(PolicyObject,
1225                               L"Secrets",
1226                               LsaDbContainerObject,
1227                               0,
1228                               &SecretsObject);
1229     if (!NT_SUCCESS(Status))
1230     {
1231         ERR("LsapCreateDbObject (Secrets) failed (Status 0x%08lx)\n", Status);
1232         goto done;
1233     }
1234
1235     /* Create the secret object */
1236     Status = LsapOpenDbObject(SecretsObject,
1237                               SecretName->Buffer,
1238                               LsaDbSecretObject,
1239                               DesiredAccess,
1240                               &SecretObject);
1241     if (!NT_SUCCESS(Status))
1242     {
1243         ERR("LsapOpenDbObject (Secret) failed (Status 0x%08lx)\n", Status);
1244         goto done;
1245     }
1246
1247 done:
1248     if (!NT_SUCCESS(Status))
1249     {
1250         if (SecretObject != NULL)
1251             LsapCloseDbObject(SecretObject);
1252     }
1253     else
1254     {
1255         *SecretHandle = (LSAPR_HANDLE)SecretObject;
1256     }
1257
1258     if (SecretsObject != NULL)
1259         LsapCloseDbObject(SecretsObject);
1260
1261     return STATUS_SUCCESS;
1262 }
1263
1264
1265 /* Function 29 */
1266 NTSTATUS WINAPI LsarSetSecret(
1267     LSAPR_HANDLE SecretHandle,
1268     PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue,
1269     PLSAPR_CR_CIPHER_VALUE EncryptedOldValue)
1270 {
1271     PLSA_DB_OBJECT SecretObject;
1272     PBYTE CurrentValue = NULL;
1273     PBYTE OldValue = NULL;
1274     ULONG CurrentValueLength = 0;
1275     ULONG OldValueLength = 0;
1276     LARGE_INTEGER Time;
1277     NTSTATUS Status;
1278
1279     TRACE("LsarSetSecret(%p %p %p)\n", SecretHandle,
1280           EncryptedCurrentValue, EncryptedOldValue);
1281
1282     /* Validate the SecretHandle */
1283     Status = LsapValidateDbObject(SecretHandle,
1284                                   LsaDbSecretObject,
1285                                   SECRET_SET_VALUE,
1286                                   &SecretObject);
1287     if (!NT_SUCCESS(Status))
1288     {
1289         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
1290         return Status;
1291     }
1292
1293     if (EncryptedCurrentValue != NULL)
1294     {
1295         /* FIXME: Decrypt the current value */
1296         CurrentValue = EncryptedCurrentValue->Buffer;
1297         CurrentValueLength = EncryptedCurrentValue->MaximumLength;
1298     }
1299
1300     /* Set the current value */
1301     Status = LsapSetObjectAttribute(SecretObject,
1302                                     L"CurrentValue",
1303                                     CurrentValue,
1304                                     CurrentValueLength);
1305     if (!NT_SUCCESS(Status))
1306     {
1307         ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
1308         goto done;
1309     }
1310
1311     /* Get the current time */
1312     Status = NtQuerySystemTime(&Time);
1313     if (!NT_SUCCESS(Status))
1314     {
1315         ERR("NtQuerySystemTime failed (Status 0x%08lx)\n", Status);
1316         goto done;
1317     }
1318
1319     /* Set the current time */
1320     Status = LsapSetObjectAttribute(SecretObject,
1321                                     L"CurrentTime",
1322                                     &Time,
1323                                     sizeof(LARGE_INTEGER));
1324     if (!NT_SUCCESS(Status))
1325     {
1326         ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
1327         goto done;
1328     }
1329
1330     if (EncryptedOldValue != NULL)
1331     {
1332         /* FIXME: Decrypt the old value */
1333         OldValue = EncryptedOldValue->Buffer;
1334         OldValueLength = EncryptedOldValue->MaximumLength;
1335     }
1336
1337     /* Set the old value */
1338     Status = LsapSetObjectAttribute(SecretObject,
1339                                     L"OldValue",
1340                                     OldValue,
1341                                     OldValueLength);
1342     if (!NT_SUCCESS(Status))
1343     {
1344         ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
1345         goto done;
1346     }
1347
1348     /* Set the old time */
1349     Status = LsapSetObjectAttribute(SecretObject,
1350                                     L"OldTime",
1351                                     &Time,
1352                                     sizeof(LARGE_INTEGER));
1353     if (!NT_SUCCESS(Status))
1354     {
1355         ERR("LsapSetObjectAttribute failed (Status 0x%08lx)\n", Status);
1356     }
1357
1358 done:
1359     return Status;
1360 }
1361
1362
1363 /* Function 30 */
1364 NTSTATUS WINAPI LsarQuerySecret(
1365     LSAPR_HANDLE SecretHandle,
1366     PLSAPR_CR_CIPHER_VALUE *EncryptedCurrentValue,
1367     PLARGE_INTEGER CurrentValueSetTime,
1368     PLSAPR_CR_CIPHER_VALUE *EncryptedOldValue,
1369     PLARGE_INTEGER OldValueSetTime)
1370 {
1371     PLSA_DB_OBJECT SecretObject;
1372     PLSAPR_CR_CIPHER_VALUE EncCurrentValue = NULL;
1373     PLSAPR_CR_CIPHER_VALUE EncOldValue = NULL;
1374     PBYTE CurrentValue = NULL;
1375     PBYTE OldValue = NULL;
1376     ULONG CurrentValueLength = 0;
1377     ULONG OldValueLength = 0;
1378     ULONG BufferSize;
1379     NTSTATUS Status;
1380
1381     TRACE("LsarQuerySecret(%p %p %p %p %p)\n", SecretHandle,
1382           EncryptedCurrentValue, CurrentValueSetTime,
1383           EncryptedOldValue, OldValueSetTime);
1384
1385     /* Validate the SecretHandle */
1386     Status = LsapValidateDbObject(SecretHandle,
1387                                   LsaDbSecretObject,
1388                                   SECRET_QUERY_VALUE,
1389                                   &SecretObject);
1390     if (!NT_SUCCESS(Status))
1391     {
1392         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
1393         return Status;
1394     }
1395
1396     if (EncryptedCurrentValue != NULL)
1397     {
1398         CurrentValueLength = 0;
1399
1400         /* Get the size of the current value */
1401         Status = LsapGetObjectAttribute(SecretObject,
1402                                         L"CurrentValue",
1403                                         NULL,
1404                                         &CurrentValueLength);
1405         if (!NT_SUCCESS(Status))
1406             goto done;
1407
1408         /* Allocate a buffer for the current value */
1409         CurrentValue = midl_user_allocate(CurrentValueLength);
1410         if (CurrentValue == NULL)
1411         {
1412             Status = STATUS_INSUFFICIENT_RESOURCES;
1413             goto done;
1414         }
1415
1416         /* Get the current value */
1417         Status = LsapGetObjectAttribute(SecretObject,
1418                                         L"CurrentValue",
1419                                         CurrentValue,
1420                                         &CurrentValueLength);
1421         if (!NT_SUCCESS(Status))
1422             goto done;
1423
1424         /* Allocate a buffer for the encrypted current value */
1425         EncCurrentValue = midl_user_allocate(sizeof(LSAPR_CR_CIPHER_VALUE));
1426         if (EncCurrentValue == NULL)
1427         {
1428             Status = STATUS_INSUFFICIENT_RESOURCES;
1429             goto done;
1430         }
1431
1432         /* FIXME: Encrypt the current value */
1433         EncCurrentValue->Length = (USHORT)(CurrentValueLength - sizeof(WCHAR));
1434         EncCurrentValue->MaximumLength = (USHORT)CurrentValueLength;
1435         EncCurrentValue->Buffer = (PBYTE)CurrentValue;
1436     }
1437
1438     if (CurrentValueSetTime != NULL)
1439     {
1440         BufferSize = sizeof(LARGE_INTEGER);
1441
1442         /* Get the current value time */
1443         Status = LsapGetObjectAttribute(SecretObject,
1444                                         L"CurrentTime",
1445                                         (PBYTE)CurrentValueSetTime,
1446                                         &BufferSize);
1447         if (!NT_SUCCESS(Status))
1448             goto done;
1449     }
1450
1451     if (EncryptedOldValue != NULL)
1452     {
1453         OldValueLength = 0;
1454
1455         /* Get the size of the old value */
1456         Status = LsapGetObjectAttribute(SecretObject,
1457                                         L"OldValue",
1458                                         NULL,
1459                                         &OldValueLength);
1460         if (!NT_SUCCESS(Status))
1461             goto done;
1462
1463         /* Allocate a buffer for the old value */
1464         OldValue = midl_user_allocate(OldValueLength);
1465         if (OldValue == NULL)
1466         {
1467             Status = STATUS_INSUFFICIENT_RESOURCES;
1468             goto done;
1469         }
1470
1471         /* Get the old value */
1472         Status = LsapGetObjectAttribute(SecretObject,
1473                                         L"OldValue",
1474                                         OldValue,
1475                                         &OldValueLength);
1476         if (!NT_SUCCESS(Status))
1477             goto done;
1478
1479         /* Allocate a buffer for the encrypted old value */
1480         EncOldValue = midl_user_allocate(sizeof(LSAPR_CR_CIPHER_VALUE) + OldValueLength);
1481         if (EncOldValue == NULL)
1482         {
1483             Status = STATUS_INSUFFICIENT_RESOURCES;
1484             goto done;
1485         }
1486
1487         /* FIXME: Encrypt the old value */
1488         EncOldValue->Length = (USHORT)(OldValueLength - sizeof(WCHAR));
1489         EncOldValue->MaximumLength = (USHORT)OldValueLength;
1490         EncOldValue->Buffer = (PBYTE)OldValue;
1491     }
1492
1493     if (OldValueSetTime != NULL)
1494     {
1495         BufferSize = sizeof(LARGE_INTEGER);
1496
1497         /* Get the old value time */
1498         Status = LsapGetObjectAttribute(SecretObject,
1499                                         L"OldTime",
1500                                         (PBYTE)OldValueSetTime,
1501                                         &BufferSize);
1502         if (!NT_SUCCESS(Status))
1503             goto done;
1504     }
1505
1506
1507 done:
1508     if (NT_SUCCESS(Status))
1509     {
1510         if (EncryptedCurrentValue != NULL)
1511             *EncryptedCurrentValue = EncCurrentValue;
1512
1513         if (EncryptedOldValue != NULL)
1514             *EncryptedOldValue = EncOldValue;
1515     }
1516     else
1517     {
1518         if (EncryptedCurrentValue != NULL)
1519             *EncryptedCurrentValue = NULL;
1520
1521         if (EncryptedOldValue != NULL)
1522             *EncryptedOldValue = NULL;
1523
1524         if (EncCurrentValue != NULL)
1525             midl_user_free(EncCurrentValue);
1526
1527         if (EncOldValue != NULL)
1528             midl_user_free(EncOldValue);
1529
1530         if (CurrentValue != NULL)
1531             midl_user_free(CurrentValue);
1532
1533         if (OldValue != NULL)
1534             midl_user_free(OldValue);
1535     }
1536
1537     TRACE("LsarQuerySecret done (Status 0x%08lx)\n", Status);
1538
1539     return Status;
1540 }
1541
1542
1543 /* Function 31 */
1544 NTSTATUS WINAPI LsarLookupPrivilegeValue(
1545     LSAPR_HANDLE PolicyHandle,
1546     PRPC_UNICODE_STRING Name,
1547     PLUID Value)
1548 {
1549     NTSTATUS Status;
1550
1551     TRACE("LsarLookupPrivilegeValue(%p, %wZ, %p)\n",
1552           PolicyHandle, Name, Value);
1553
1554     Status = LsapValidateDbObject(PolicyHandle,
1555                                   LsaDbPolicyObject,
1556                                   POLICY_LOOKUP_NAMES,
1557                                   NULL);
1558     if (!NT_SUCCESS(Status))
1559     {
1560         ERR("Invalid handle (Status %lx)\n", Status);
1561         return Status;
1562     }
1563
1564     TRACE("Privilege: %wZ\n", Name);
1565
1566     Status = LsarpLookupPrivilegeValue((PUNICODE_STRING)Name,
1567                                        Value);
1568
1569     return Status;
1570 }
1571
1572
1573 /* Function 32 */
1574 NTSTATUS WINAPI LsarLookupPrivilegeName(
1575     LSAPR_HANDLE PolicyHandle,
1576     PLUID Value,
1577     PRPC_UNICODE_STRING *Name)
1578 {
1579     NTSTATUS Status;
1580
1581     TRACE("LsarLookupPrivilegeName(%p, %p, %p)\n",
1582           PolicyHandle, Value, Name);
1583
1584     Status = LsapValidateDbObject(PolicyHandle,
1585                                   LsaDbPolicyObject,
1586                                   POLICY_LOOKUP_NAMES,
1587                                   NULL);
1588     if (!NT_SUCCESS(Status))
1589     {
1590         ERR("Invalid handle\n");
1591         return Status;
1592     }
1593
1594     Status = LsarpLookupPrivilegeName(Value, (PUNICODE_STRING*)Name);
1595
1596     return Status;
1597 }
1598
1599
1600 /* Function 33 */
1601 NTSTATUS WINAPI LsarLookupPrivilegeDisplayName(
1602     LSAPR_HANDLE PolicyHandle,
1603     PRPC_UNICODE_STRING Name,
1604     USHORT ClientLanguage,
1605     USHORT ClientSystemDefaultLanguage,
1606     PRPC_UNICODE_STRING *DisplayName,
1607     USHORT *LanguageReturned)
1608 {
1609     UNIMPLEMENTED;
1610     return STATUS_NOT_IMPLEMENTED;
1611 }
1612
1613
1614 /* Function 34 */
1615 NTSTATUS WINAPI LsarDeleteObject(
1616     LSAPR_HANDLE *ObjectHandle)
1617 {
1618     UNIMPLEMENTED;
1619     return STATUS_NOT_IMPLEMENTED;
1620 }
1621
1622
1623 /* Function 35 */
1624 NTSTATUS WINAPI LsarEnumerateAccountsWithUserRight(
1625     LSAPR_HANDLE PolicyHandle,
1626     PRPC_UNICODE_STRING UserRight,
1627     PLSAPR_ACCOUNT_ENUM_BUFFER EnumerationBuffer)
1628 {
1629     UNIMPLEMENTED;
1630     return STATUS_NOT_IMPLEMENTED;
1631 }
1632
1633
1634 /* Function 36 */
1635 NTSTATUS WINAPI LsarEnmuerateAccountRights(
1636     LSAPR_HANDLE PolicyHandle,
1637     PRPC_SID AccountSid,
1638     PLSAPR_USER_RIGHT_SET UserRights)
1639 {
1640     PLSA_DB_OBJECT PolicyObject;
1641     NTSTATUS Status;
1642
1643     FIXME("(%p,%p,%p) stub\n", PolicyHandle, AccountSid, UserRights);
1644
1645     Status = LsapValidateDbObject(PolicyHandle,
1646                                   LsaDbPolicyObject,
1647                                   ACCOUNT_VIEW,
1648                                   &PolicyObject);
1649     if (!NT_SUCCESS(Status))
1650         return Status;
1651
1652     UserRights->Entries = 0;
1653     UserRights->UserRights = NULL;
1654     return STATUS_OBJECT_NAME_NOT_FOUND;
1655 }
1656
1657
1658 /* Function 37 */
1659 NTSTATUS WINAPI LsarAddAccountRights(
1660     LSAPR_HANDLE PolicyHandle,
1661     PRPC_SID AccountSid,
1662     PLSAPR_USER_RIGHT_SET UserRights)
1663 {
1664     UNIMPLEMENTED;
1665     return STATUS_NOT_IMPLEMENTED;
1666 }
1667
1668
1669 /* Function 38 */
1670 NTSTATUS WINAPI LsarRemoveAccountRights(
1671     LSAPR_HANDLE PolicyHandle,
1672     PRPC_SID AccountSid,
1673     BOOL AllRights,
1674     PLSAPR_USER_RIGHT_SET UserRights)
1675 {
1676     UNIMPLEMENTED;
1677     return STATUS_NOT_IMPLEMENTED;
1678 }
1679
1680
1681 /* Function 39 */
1682 NTSTATUS WINAPI LsarQueryTrustedDomainInfo(
1683     LSAPR_HANDLE PolicyHandle,
1684     PRPC_SID TrustedDomainSid,
1685     TRUSTED_INFORMATION_CLASS InformationClass,
1686     PLSAPR_TRUSTED_DOMAIN_INFO *TrustedDomainInformation)
1687 {
1688     UNIMPLEMENTED;
1689     return STATUS_NOT_IMPLEMENTED;
1690 }
1691
1692
1693 /* Function 40 */
1694 NTSTATUS WINAPI LsarSetTrustedDomainInfo(
1695     LSAPR_HANDLE PolicyHandle,
1696     PRPC_SID TrustedDomainSid,
1697     TRUSTED_INFORMATION_CLASS InformationClass,
1698     PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation)
1699 {
1700     UNIMPLEMENTED;
1701     return STATUS_NOT_IMPLEMENTED;
1702 }
1703
1704
1705 /* Function 41 */
1706 NTSTATUS WINAPI LsarDeleteTrustedDomain(
1707     LSAPR_HANDLE PolicyHandle,
1708     PRPC_SID TrustedDomainSid)
1709 {
1710     UNIMPLEMENTED;
1711     return STATUS_NOT_IMPLEMENTED;
1712 }
1713
1714
1715 /* Function 42 */
1716 NTSTATUS WINAPI LsarStorePrivateData(
1717     LSAPR_HANDLE PolicyHandle,
1718     PRPC_UNICODE_STRING KeyName,
1719     PLSAPR_CR_CIPHER_VALUE EncryptedData)
1720 {
1721     UNIMPLEMENTED;
1722     return STATUS_NOT_IMPLEMENTED;
1723 }
1724
1725
1726 /* Function 43 */
1727 NTSTATUS WINAPI LsarRetrievePrivateData(
1728     LSAPR_HANDLE PolicyHandle,
1729     PRPC_UNICODE_STRING KeyName,
1730     PLSAPR_CR_CIPHER_VALUE *EncryptedData)
1731 {
1732     UNIMPLEMENTED;
1733     return STATUS_NOT_IMPLEMENTED;
1734 }
1735
1736
1737 /* Function 44 */
1738 NTSTATUS WINAPI LsarOpenPolicy2(
1739     LPWSTR SystemName,
1740     PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,
1741     ACCESS_MASK DesiredAccess,
1742     LSAPR_HANDLE *PolicyHandle)
1743 {
1744     UNIMPLEMENTED;
1745     return STATUS_NOT_IMPLEMENTED;
1746 }
1747
1748
1749 /* Function 45 */
1750 NTSTATUS WINAPI LsarGetUserName(
1751     LPWSTR SystemName,
1752     PRPC_UNICODE_STRING *UserName,
1753     PRPC_UNICODE_STRING *DomainName)
1754 {
1755     UNIMPLEMENTED;
1756     return STATUS_NOT_IMPLEMENTED;
1757 }
1758
1759
1760 /* Function 46 */
1761 NTSTATUS WINAPI LsarQueryInformationPolicy2(
1762     LSAPR_HANDLE PolicyHandle,
1763     POLICY_INFORMATION_CLASS InformationClass,
1764     unsigned long *PolicyInformation)
1765 {
1766     UNIMPLEMENTED;
1767     return STATUS_NOT_IMPLEMENTED;
1768 }
1769
1770
1771 /* Function 47 */
1772 NTSTATUS WINAPI LsarSetInformationPolicy2(
1773     LSAPR_HANDLE PolicyHandle,
1774     POLICY_INFORMATION_CLASS InformationClass,
1775     unsigned long PolicyInformation)
1776 {
1777     UNIMPLEMENTED;
1778     return STATUS_NOT_IMPLEMENTED;
1779 }
1780
1781
1782 /* Function 48 */
1783 NTSTATUS WINAPI LsarQueryTrustedDomainInfoByName(
1784     LSAPR_HANDLE PolicyHandle,
1785     PRPC_UNICODE_STRING TrustedDomainName,
1786     POLICY_INFORMATION_CLASS InformationClass,
1787     unsigned long *PolicyInformation)
1788 {
1789     UNIMPLEMENTED;
1790     return STATUS_NOT_IMPLEMENTED;
1791 }
1792
1793
1794 /* Function 49 */
1795 NTSTATUS WINAPI LsarSetTrustedDomainInfoByName(
1796     LSAPR_HANDLE PolicyHandle,
1797     PRPC_UNICODE_STRING TrustedDomainName,
1798     POLICY_INFORMATION_CLASS InformationClass,
1799     unsigned long PolicyInformation)
1800 {
1801     UNIMPLEMENTED;
1802     return STATUS_NOT_IMPLEMENTED;
1803 }
1804
1805
1806 /* Function 50 */
1807 NTSTATUS WINAPI LsarEnumerateTrustedDomainsEx(
1808     LSAPR_HANDLE PolicyHandle,
1809     DWORD *EnumerationContext,
1810     PLSAPR_TRUSTED_ENUM_BUFFER_EX EnumerationBuffer,
1811     DWORD PreferedMaximumLength)
1812 {
1813     UNIMPLEMENTED;
1814     return STATUS_NOT_IMPLEMENTED;
1815 }
1816
1817
1818 /* Function 51 */
1819 NTSTATUS WINAPI LsarCreateTrustedDomainEx(
1820     LSAPR_HANDLE PolicyHandle,
1821     PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
1822     PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION AuthentificationInformation,
1823     ACCESS_MASK DesiredAccess,
1824     LSAPR_HANDLE *TrustedDomainHandle)
1825 {
1826     UNIMPLEMENTED;
1827     return STATUS_NOT_IMPLEMENTED;
1828 }
1829
1830
1831 /* Function 52 */
1832 NTSTATUS WINAPI LsarSetPolicyReplicationHandle(
1833     PLSAPR_HANDLE PolicyHandle)
1834 {
1835     /* Deprecated */
1836     return STATUS_NOT_IMPLEMENTED;
1837 }
1838
1839
1840 /* Function 53 */
1841 NTSTATUS WINAPI LsarQueryDomainInformationPolicy(
1842     LSAPR_HANDLE PolicyHandle,
1843     POLICY_INFORMATION_CLASS InformationClass,
1844     unsigned long *PolicyInformation)
1845 {
1846     UNIMPLEMENTED;
1847     return STATUS_NOT_IMPLEMENTED;
1848 }
1849
1850
1851 /* Function 54 */
1852 NTSTATUS WINAPI LsarSetDomainInformationPolicy(
1853     LSAPR_HANDLE PolicyHandle,
1854     POLICY_INFORMATION_CLASS InformationClass,
1855     unsigned long PolicyInformation)
1856 {
1857     UNIMPLEMENTED;
1858     return STATUS_NOT_IMPLEMENTED;
1859 }
1860
1861
1862 /* Function 55 */
1863 NTSTATUS WINAPI LsarOpenTrustedDomainByName(
1864     LSAPR_HANDLE PolicyHandle,
1865     PRPC_UNICODE_STRING TrustedDomainName,
1866     ACCESS_MASK DesiredAccess,
1867     LSAPR_HANDLE *TrustedDomainHandle)
1868 {
1869     UNIMPLEMENTED;
1870     return STATUS_NOT_IMPLEMENTED;
1871 }
1872
1873
1874 /* Function 56 */
1875 NTSTATUS WINAPI LsarTestCall(
1876     handle_t hBinding)
1877 {
1878     UNIMPLEMENTED;
1879     return STATUS_NOT_IMPLEMENTED;
1880 }
1881
1882
1883 /* Function 57 */
1884 NTSTATUS WINAPI LsarLookupSids2(
1885     LSAPR_HANDLE PolicyHandle,
1886     PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
1887     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1888     PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,
1889     LSAP_LOOKUP_LEVEL LookupLevel,
1890     DWORD *MappedCount,
1891     DWORD LookupOptions,
1892     DWORD ClientRevision)
1893 {
1894     UNIMPLEMENTED;
1895     return STATUS_NOT_IMPLEMENTED;
1896 }
1897
1898
1899 /* Function 58 */
1900 NTSTATUS WINAPI LsarLookupNames2(
1901     LSAPR_HANDLE PolicyHandle,
1902     DWORD Count,
1903     PRPC_UNICODE_STRING Names,
1904     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1905     PLSAPR_TRANSLATED_SIDS_EX TranslatedSids,
1906     LSAP_LOOKUP_LEVEL LookupLevel,
1907     DWORD *MappedCount,
1908     DWORD LookupOptions,
1909     DWORD ClientRevision)
1910 {
1911     UNIMPLEMENTED;
1912     return STATUS_NOT_IMPLEMENTED;
1913 }
1914
1915
1916 /* Function 59 */
1917 NTSTATUS WINAPI LsarCreateTrustedDomainEx2(
1918     LSAPR_HANDLE PolicyHandle,
1919     PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
1920     PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION_INTERNAL AuthentificationInformation,
1921     ACCESS_MASK DesiredAccess,
1922     LSAPR_HANDLE *TrustedDomainHandle)
1923 {
1924     UNIMPLEMENTED;
1925     return STATUS_NOT_IMPLEMENTED;
1926 }
1927
1928
1929 /* Function 60 */
1930 NTSTATUS WINAPI CredrWrite(
1931     handle_t hBinding)
1932 {
1933     UNIMPLEMENTED;
1934     return STATUS_NOT_IMPLEMENTED;
1935 }
1936
1937
1938 /* Function 61 */
1939 NTSTATUS WINAPI CredrRead(
1940     handle_t hBinding)
1941 {
1942     UNIMPLEMENTED;
1943     return STATUS_NOT_IMPLEMENTED;
1944 }
1945
1946
1947 /* Function 62 */
1948 NTSTATUS WINAPI CredrEnumerate(
1949     handle_t hBinding)
1950 {
1951     UNIMPLEMENTED;
1952     return STATUS_NOT_IMPLEMENTED;
1953 }
1954
1955
1956 /* Function 63 */
1957 NTSTATUS WINAPI CredrWriteDomainCredentials(
1958     handle_t hBinding)
1959 {
1960     UNIMPLEMENTED;
1961     return STATUS_NOT_IMPLEMENTED;
1962 }
1963
1964
1965 /* Function 64 */
1966 NTSTATUS WINAPI CredrReadDomainCredentials(
1967     handle_t hBinding)
1968 {
1969     UNIMPLEMENTED;
1970     return STATUS_NOT_IMPLEMENTED;
1971 }
1972
1973
1974 /* Function 65 */
1975 NTSTATUS WINAPI CredrDelete(
1976     handle_t hBinding)
1977 {
1978     UNIMPLEMENTED;
1979     return STATUS_NOT_IMPLEMENTED;
1980 }
1981
1982
1983 /* Function 66 */
1984 NTSTATUS WINAPI CredrGetTargetInfo(
1985     handle_t hBinding)
1986 {
1987     UNIMPLEMENTED;
1988     return STATUS_NOT_IMPLEMENTED;
1989 }
1990
1991
1992 /* Function 67 */
1993 NTSTATUS WINAPI CredrProfileLoaded(
1994     handle_t hBinding)
1995 {
1996     UNIMPLEMENTED;
1997     return STATUS_NOT_IMPLEMENTED;
1998 }
1999
2000
2001 /* Function 68 */
2002 NTSTATUS WINAPI LsarLookupNames3(
2003     LSAPR_HANDLE PolicyHandle,
2004     DWORD Count,
2005     PRPC_UNICODE_STRING Names,
2006     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
2007     PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,
2008     LSAP_LOOKUP_LEVEL LookupLevel,
2009     DWORD *MappedCount,
2010     DWORD LookupOptions,
2011     DWORD ClientRevision)
2012 {
2013     SID_IDENTIFIER_AUTHORITY IdentifierAuthority = {SECURITY_NT_AUTHORITY};
2014     static const UNICODE_STRING DomainName = RTL_CONSTANT_STRING(L"DOMAIN");
2015     PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer = NULL;
2016     PLSAPR_TRANSLATED_SID_EX2 SidsBuffer = NULL;
2017     ULONG SidsBufferLength;
2018     ULONG DomainSidLength;
2019     ULONG AccountSidLength;
2020     PSID DomainSid;
2021     PSID AccountSid;
2022     ULONG i;
2023     NTSTATUS Status;
2024
2025     TRACE("LsarLookupNames3(%p, %lu, %p, %p, %p, %d, %p, %lu, %lu)\n",
2026           PolicyHandle, Count, Names, ReferencedDomains, TranslatedSids,
2027           LookupLevel, MappedCount, LookupOptions, ClientRevision);
2028
2029     if (Count == 0)
2030         return STATUS_NONE_MAPPED;
2031
2032     TranslatedSids->Entries = Count;
2033     TranslatedSids->Sids = NULL;
2034     *ReferencedDomains = NULL;
2035
2036     SidsBufferLength = Count * sizeof(LSAPR_TRANSLATED_SID_EX2);
2037     SidsBuffer = MIDL_user_allocate(SidsBufferLength);
2038     if (SidsBuffer == NULL)
2039         return STATUS_INSUFFICIENT_RESOURCES;
2040
2041     for (i = 0; i < Count; i++)
2042     {
2043         SidsBuffer[i].Use = SidTypeUser;
2044         SidsBuffer[i].Sid = NULL;
2045         SidsBuffer[i].DomainIndex = -1;
2046         SidsBuffer[i].Flags = 0;
2047     }
2048
2049     DomainsBuffer = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
2050     if (DomainsBuffer == NULL)
2051     {
2052         MIDL_user_free(SidsBuffer);
2053         return STATUS_INSUFFICIENT_RESOURCES;
2054     }
2055
2056     DomainsBuffer->Entries = Count;
2057     DomainsBuffer->Domains = MIDL_user_allocate(Count * sizeof(LSA_TRUST_INFORMATION));
2058     if (DomainsBuffer->Domains == NULL)
2059     {
2060         MIDL_user_free(DomainsBuffer);
2061         MIDL_user_free(SidsBuffer);
2062         return STATUS_INSUFFICIENT_RESOURCES;
2063     }
2064
2065     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
2066                                          2,
2067                                          SECURITY_BUILTIN_DOMAIN_RID,
2068                                          DOMAIN_ALIAS_RID_ADMINS,
2069                                          0, 0, 0, 0, 0, 0,
2070                                          &DomainSid);
2071     if (!NT_SUCCESS(Status))
2072     {
2073         MIDL_user_free(DomainsBuffer->Domains);
2074         MIDL_user_free(DomainsBuffer);
2075         MIDL_user_free(SidsBuffer);
2076         return Status;
2077     }
2078
2079     DomainSidLength = RtlLengthSid(DomainSid);
2080
2081     for (i = 0; i < Count; i++)
2082     {
2083         DomainsBuffer->Domains[i].Sid = MIDL_user_allocate(DomainSidLength);
2084         RtlCopyMemory(DomainsBuffer->Domains[i].Sid,
2085                       DomainSid,
2086                       DomainSidLength);
2087
2088         DomainsBuffer->Domains[i].Name.Buffer = MIDL_user_allocate(DomainName.MaximumLength);
2089         DomainsBuffer->Domains[i].Name.Length = DomainName.Length;
2090         DomainsBuffer->Domains[i].Name.MaximumLength = DomainName.MaximumLength;
2091         RtlCopyMemory(DomainsBuffer->Domains[i].Name.Buffer,
2092                       DomainName.Buffer,
2093                       DomainName.MaximumLength);
2094     }
2095
2096     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
2097                                          3,
2098                                          SECURITY_BUILTIN_DOMAIN_RID,
2099                                          DOMAIN_ALIAS_RID_ADMINS,
2100                                          DOMAIN_USER_RID_ADMIN,
2101                                          0, 0, 0, 0, 0,
2102                                          &AccountSid);
2103     if (!NT_SUCCESS(Status))
2104     {
2105         MIDL_user_free(DomainsBuffer->Domains);
2106         MIDL_user_free(DomainsBuffer);
2107         MIDL_user_free(SidsBuffer);
2108         return Status;
2109     }
2110
2111     AccountSidLength = RtlLengthSid(AccountSid);
2112
2113     for (i = 0; i < Count; i++)
2114     {
2115         SidsBuffer[i].Use = SidTypeWellKnownGroup;
2116         SidsBuffer[i].Sid = MIDL_user_allocate(AccountSidLength);
2117
2118         RtlCopyMemory(SidsBuffer[i].Sid,
2119                       AccountSid,
2120                       AccountSidLength);
2121
2122         SidsBuffer[i].DomainIndex = i;
2123         SidsBuffer[i].Flags = 0;
2124     }
2125
2126     *ReferencedDomains = DomainsBuffer;
2127     *MappedCount = Count;
2128
2129     TranslatedSids->Entries = Count;
2130     TranslatedSids->Sids = SidsBuffer;
2131
2132     return STATUS_SUCCESS;
2133 }
2134
2135
2136 /* Function 69 */
2137 NTSTATUS WINAPI CredrGetSessionTypes(
2138     handle_t hBinding)
2139 {
2140     UNIMPLEMENTED;
2141     return STATUS_NOT_IMPLEMENTED;
2142 }
2143
2144
2145 /* Function 70 */
2146 NTSTATUS WINAPI LsarRegisterAuditEvent(
2147     handle_t hBinding)
2148 {
2149     UNIMPLEMENTED;
2150     return STATUS_NOT_IMPLEMENTED;
2151 }
2152
2153
2154 /* Function 71 */
2155 NTSTATUS WINAPI LsarGenAuditEvent(
2156     handle_t hBinding)
2157 {
2158     UNIMPLEMENTED;
2159     return STATUS_NOT_IMPLEMENTED;
2160 }
2161
2162
2163 /* Function 72 */
2164 NTSTATUS WINAPI LsarUnregisterAuditEvent(
2165     handle_t hBinding)
2166 {
2167     UNIMPLEMENTED;
2168     return STATUS_NOT_IMPLEMENTED;
2169 }
2170
2171
2172 /* Function 73 */
2173 NTSTATUS WINAPI LsarQueryForestTrustInformation(
2174     LSAPR_HANDLE PolicyHandle,
2175     PLSA_UNICODE_STRING TrustedDomainName,
2176     LSA_FOREST_TRUST_RECORD_TYPE HighestRecordType,
2177     PLSA_FOREST_TRUST_INFORMATION *ForestTrustInfo)
2178 {
2179     UNIMPLEMENTED;
2180     return STATUS_NOT_IMPLEMENTED;
2181 }
2182
2183
2184 /* Function 74 */
2185 NTSTATUS WINAPI LsarSetForestTrustInformation(
2186     LSAPR_HANDLE PolicyHandle,
2187     PLSA_UNICODE_STRING TrustedDomainName,
2188     LSA_FOREST_TRUST_RECORD_TYPE HighestRecordType,
2189     PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
2190     BOOL CheckOnly,
2191     PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
2192 {
2193     UNIMPLEMENTED;
2194     return STATUS_NOT_IMPLEMENTED;
2195 }
2196
2197
2198 /* Function 75 */
2199 NTSTATUS WINAPI CredrRename(
2200     handle_t hBinding)
2201 {
2202     UNIMPLEMENTED;
2203     return STATUS_NOT_IMPLEMENTED;
2204 }
2205
2206
2207 /* Function 76 */
2208 NTSTATUS WINAPI LsarLookupSids3(
2209     LSAPR_HANDLE PolicyHandle,
2210     PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
2211     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
2212     PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,
2213     LSAP_LOOKUP_LEVEL LookupLevel,
2214     DWORD *MappedCount,
2215     DWORD LookupOptions,
2216     DWORD ClientRevision)
2217 {
2218     UNIMPLEMENTED;
2219     return STATUS_NOT_IMPLEMENTED;
2220 }
2221
2222
2223 /* Function 77 */
2224 NTSTATUS WINAPI LsarLookupNames4(
2225     handle_t RpcHandle,
2226     DWORD Count,
2227     PRPC_UNICODE_STRING Names,
2228     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
2229     PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,
2230     LSAP_LOOKUP_LEVEL LookupLevel,
2231     DWORD *MappedCount,
2232     DWORD LookupOptions,
2233     DWORD ClientRevision)
2234 {
2235     UNIMPLEMENTED;
2236     return STATUS_NOT_IMPLEMENTED;
2237 }
2238
2239
2240 /* Function 78 */
2241 NTSTATUS WINAPI LsarOpenPolicySce(
2242     handle_t hBinding)
2243 {
2244     UNIMPLEMENTED;
2245     return STATUS_NOT_IMPLEMENTED;
2246 }
2247
2248
2249 /* Function 79 */
2250 NTSTATUS WINAPI LsarAdtRegisterSecurityEventSource(
2251     handle_t hBinding)
2252 {
2253     UNIMPLEMENTED;
2254     return STATUS_NOT_IMPLEMENTED;
2255 }
2256
2257
2258 /* Function 80 */
2259 NTSTATUS WINAPI LsarAdtUnregisterSecurityEventSource(
2260     handle_t hBinding)
2261 {
2262     UNIMPLEMENTED;
2263     return STATUS_NOT_IMPLEMENTED;
2264 }
2265
2266
2267 /* Function 81 */
2268 NTSTATUS WINAPI LsarAdtReportSecurityEvent(
2269     handle_t hBinding)
2270 {
2271     UNIMPLEMENTED;
2272     return STATUS_NOT_IMPLEMENTED;
2273 }
2274
2275
2276 /* Function 82 */
2277 NTSTATUS WINAPI CredrFindBestCredential(
2278     handle_t hBinding)
2279 {
2280     UNIMPLEMENTED;
2281     return STATUS_NOT_IMPLEMENTED;
2282 }
2283
2284
2285 /* Function 83 */
2286 NTSTATUS WINAPI LsarSetAuditPolicy(
2287     handle_t hBinding)
2288 {
2289     UNIMPLEMENTED;
2290     return STATUS_NOT_IMPLEMENTED;
2291 }
2292
2293
2294 /* Function 84 */
2295 NTSTATUS WINAPI LsarQueryAuditPolicy(
2296     handle_t hBinding)
2297 {
2298     UNIMPLEMENTED;
2299     return STATUS_NOT_IMPLEMENTED;
2300 }
2301
2302
2303 /* Function 85 */
2304 NTSTATUS WINAPI LsarEnumerateAuditPolicy(
2305     handle_t hBinding)
2306 {
2307     UNIMPLEMENTED;
2308     return STATUS_NOT_IMPLEMENTED;
2309 }
2310
2311
2312 /* Function 86 */
2313 NTSTATUS WINAPI LsarEnumerateAuditCategories(
2314     handle_t hBinding)
2315 {
2316     UNIMPLEMENTED;
2317     return STATUS_NOT_IMPLEMENTED;
2318 }
2319
2320
2321 /* Function 87 */
2322 NTSTATUS WINAPI LsarEnumerateAuditSubCategories(
2323     handle_t hBinding)
2324 {
2325     UNIMPLEMENTED;
2326     return STATUS_NOT_IMPLEMENTED;
2327 }
2328
2329
2330 /* Function 88 */
2331 NTSTATUS WINAPI LsarLookupAuditCategoryName(
2332     handle_t hBinding)
2333 {
2334     UNIMPLEMENTED;
2335     return STATUS_NOT_IMPLEMENTED;
2336 }
2337
2338
2339 /* Function 89 */
2340 NTSTATUS WINAPI LsarLookupAuditSubCategoryName(
2341     handle_t hBinding)
2342 {
2343     UNIMPLEMENTED;
2344     return STATUS_NOT_IMPLEMENTED;
2345 }
2346
2347
2348 /* Function 90 */
2349 NTSTATUS WINAPI LsarSetAuditSecurity(
2350     handle_t hBinding)
2351 {
2352     UNIMPLEMENTED;
2353     return STATUS_NOT_IMPLEMENTED;
2354 }
2355
2356
2357 /* Function 91 */
2358 NTSTATUS WINAPI LsarQueryAuditSecurity(
2359     handle_t hBinding)
2360 {
2361     UNIMPLEMENTED;
2362     return STATUS_NOT_IMPLEMENTED;
2363 }
2364
2365
2366 /* Function 92 */
2367 NTSTATUS WINAPI CredReadByTokenHandle(
2368     handle_t hBinding)
2369 {
2370     UNIMPLEMENTED;
2371     return STATUS_NOT_IMPLEMENTED;
2372 }
2373
2374
2375 /* Function 93 */
2376 NTSTATUS WINAPI CredrRestoreCredentials(
2377     handle_t hBinding)
2378 {
2379     UNIMPLEMENTED;
2380     return STATUS_NOT_IMPLEMENTED;
2381 }
2382
2383
2384 /* Function 94 */
2385 NTSTATUS WINAPI CredrBackupCredentials(
2386     handle_t hBinding)
2387 {
2388     UNIMPLEMENTED;
2389     return STATUS_NOT_IMPLEMENTED;
2390 }
2391
2392 /* EOF */