reactos/dll/win32/lsasrv/lsarpc.c

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