ReactOS Development > Doxygen

00001 /*
00002  * COPYRIGHT:       See COPYING in the top level directory
00003  * PROJECT:         Local Security Authority (LSA) Server
00004  * FILE:            reactos/dll/win32/lsasrv/lsarpc.h
00005  * PURPOSE:         RPC interface functions
00006  *
00007  * PROGRAMMERS:     Eric Kohl
00008  */
00009 
00010 /* INCLUDES ****************************************************************/
00011 
00012 #include "lsasrv.h"
00013 
00014 
00015 static RTL_CRITICAL_SECTION PolicyHandleTableLock;
00016 
00017 WINE_DEFAULT_DEBUG_CHANNEL(lsasrv);
00018 
00019 
00020 /* FUNCTIONS ***************************************************************/
00021 
00022 
00023 VOID
00024 LsarStartRpcServer(VOID)
00025 {
00026     RPC_STATUS Status;
00027 
00028     RtlInitializeCriticalSection(&PolicyHandleTableLock);
00029 
00030     TRACE("LsarStartRpcServer() called\n");
00031 
00032     Status = RpcServerUseProtseqEpW(L"ncacn_np",
00033                                     10,
00034                                     L"\\pipe\\lsarpc",
00035                                     NULL);
00036     if (Status != RPC_S_OK)
00037     {
00038         WARN("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
00039         return;
00040     }
00041 
00042     Status = RpcServerRegisterIf(lsarpc_v0_0_s_ifspec,
00043                                  NULL,
00044                                  NULL);
00045     if (Status != RPC_S_OK)
00046     {
00047         WARN("RpcServerRegisterIf() failed (Status %lx)\n", Status);
00048         return;
00049     }
00050 
00051     Status = RpcServerListen(1, 20, TRUE);
00052     if (Status != RPC_S_OK)
00053     {
00054         WARN("RpcServerListen() failed (Status %lx)\n", Status);
00055         return;
00056     }
00057 
00058     TRACE("LsarStartRpcServer() done\n");
00059 }
00060 
00061 
00062 void __RPC_USER LSAPR_HANDLE_rundown(LSAPR_HANDLE hHandle)
00063 {
00064 
00065 }
00066 
00067 
00068 /* Function 0 */
00069 NTSTATUS WINAPI LsarClose(
00070     LSAPR_HANDLE *ObjectHandle)
00071 {
00072     PLSA_DB_OBJECT DbObject;
00073     NTSTATUS Status = STATUS_SUCCESS;
00074 
00075     TRACE("0x%p\n", ObjectHandle);
00076 
00077 //    RtlEnterCriticalSection(&PolicyHandleTableLock);
00078 
00079     Status = LsapValidateDbObject(*ObjectHandle,
00080                                   LsaDbIgnoreObject,
00081                                   0,
00082                                   &DbObject);
00083     if (Status == STATUS_SUCCESS)
00084     {
00085         Status = LsapCloseDbObject(DbObject);
00086         *ObjectHandle = NULL;
00087     }
00088 
00089 //    RtlLeaveCriticalSection(&PolicyHandleTableLock);
00090 
00091     return Status;
00092 }
00093 
00094 
00095 /* Function 1 */
00096 NTSTATUS WINAPI LsarDelete(
00097     LSAPR_HANDLE ObjectHandle)
00098 {
00099     /* Deprecated */
00100     return STATUS_NOT_SUPPORTED;
00101 }
00102 
00103 
00104 /* Function 2 */
00105 NTSTATUS WINAPI LsarEnumeratePrivileges(
00106     LSAPR_HANDLE PolicyHandle,
00107     DWORD *EnumerationContext,
00108     PLSAPR_PRIVILEGE_ENUM_BUFFER EnumerationBuffer,
00109     DWORD PreferedMaximumLength)
00110 {
00111     UNIMPLEMENTED;
00112     return STATUS_NOT_IMPLEMENTED;
00113 }
00114 
00115 
00116 /* Function 3 */
00117 NTSTATUS WINAPI LsarQuerySecurityObject(
00118     LSAPR_HANDLE ObjectHandle,
00119     SECURITY_INFORMATION SecurityInformation,
00120     PLSAPR_SR_SECURITY_DESCRIPTOR *SecurityDescriptor)
00121 {
00122     UNIMPLEMENTED;
00123     return STATUS_NOT_IMPLEMENTED;
00124 }
00125 
00126 
00127 /* Function 4 */
00128 NTSTATUS WINAPI LsarSetSecurityObject(
00129     LSAPR_HANDLE ObjectHandle,
00130     SECURITY_INFORMATION SecurityInformation,
00131     PLSAPR_SR_SECURITY_DESCRIPTOR SecurityDescriptor)
00132 {
00133     UNIMPLEMENTED;
00134     return STATUS_NOT_IMPLEMENTED;
00135 }
00136 
00137 
00138 /* Function 5 */
00139 NTSTATUS WINAPI LsarChangePassword(
00140     handle_t IDL_handle,
00141     PRPC_UNICODE_STRING String1,
00142     PRPC_UNICODE_STRING String2,
00143     PRPC_UNICODE_STRING String3,
00144     PRPC_UNICODE_STRING String4,
00145     PRPC_UNICODE_STRING String5)
00146 {
00147     /* Deprecated */
00148     return STATUS_NOT_IMPLEMENTED;
00149 }
00150 
00151 
00152 /* Function 6 */
00153 NTSTATUS WINAPI LsarOpenPolicy(
00154     LPWSTR SystemName,
00155     PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,
00156     ACCESS_MASK DesiredAccess,
00157     LSAPR_HANDLE *PolicyHandle)
00158 {
00159     PLSA_DB_OBJECT PolicyObject;
00160     NTSTATUS Status;
00161 
00162     TRACE("LsarOpenPolicy called!\n");
00163 
00164     RtlEnterCriticalSection(&PolicyHandleTableLock);
00165 
00166     Status = LsapOpenDbObject(NULL,
00167                               L"Policy",
00168                               LsaDbPolicyObject,
00169                               DesiredAccess,
00170                               &PolicyObject);
00171 
00172     RtlLeaveCriticalSection(&PolicyHandleTableLock);
00173 
00174     if (NT_SUCCESS(Status))
00175         *PolicyHandle = (LSAPR_HANDLE)PolicyObject;
00176 
00177     TRACE("LsarOpenPolicy done!\n");
00178 
00179     return Status;
00180 }
00181 
00182 
00183 /* Function 7 */
00184 NTSTATUS WINAPI LsarQueryInformationPolicy(
00185     LSAPR_HANDLE PolicyHandle,
00186     POLICY_INFORMATION_CLASS InformationClass,
00187     PLSAPR_POLICY_INFORMATION *PolicyInformation)
00188 {
00189     PLSA_DB_OBJECT DbObject;
00190     NTSTATUS Status;
00191 
00192     TRACE("LsarQueryInformationPolicy(%p,0x%08x,%p)\n",
00193           PolicyHandle, InformationClass, PolicyInformation);
00194 
00195     if (PolicyInformation)
00196     {
00197         TRACE("*PolicyInformation %p\n", *PolicyInformation);
00198     }
00199 
00200     Status = LsapValidateDbObject(PolicyHandle,
00201                                   LsaDbPolicyObject,
00202                                   0, /* FIXME */
00203                                   &DbObject);
00204     if (!NT_SUCCESS(Status))
00205         return Status;
00206 
00207     switch (InformationClass)
00208     {
00209         case PolicyAuditEventsInformation:   /* 2 */
00210             Status = LsarQueryAuditEvents(PolicyHandle,
00211                                           PolicyInformation);
00212             break;
00213 
00214         case PolicyPrimaryDomainInformation: /* 3 */
00215             Status = LsarQueryPrimaryDomain(PolicyHandle,
00216                                             PolicyInformation);
00217             break;
00218 
00219         case PolicyAccountDomainInformation: /* 5 */
00220             Status = LsarQueryAccountDomain(PolicyHandle,
00221                                             PolicyInformation);
00222             break;
00223 
00224         case PolicyDnsDomainInformation:     /* 12 (0xc) */
00225             Status = LsarQueryDnsDomain(PolicyHandle,
00226                                         PolicyInformation);
00227             break;
00228 
00229         case PolicyAuditLogInformation:
00230         case PolicyPdAccountInformation:
00231         case PolicyLsaServerRoleInformation:
00232         case PolicyReplicaSourceInformation:
00233         case PolicyDefaultQuotaInformation:
00234         case PolicyModificationInformation:
00235         case PolicyAuditFullSetInformation:
00236         case PolicyAuditFullQueryInformation:
00237         case PolicyEfsInformation:
00238             FIXME("category not implemented\n");
00239             Status = STATUS_UNSUCCESSFUL;
00240             break;
00241     }
00242 
00243     return Status;
00244 }
00245 
00246 
00247 /* Function 8 */
00248 NTSTATUS WINAPI LsarSetInformationPolicy(
00249     LSAPR_HANDLE PolicyHandle,
00250     POLICY_INFORMATION_CLASS InformationClass,
00251     PLSAPR_POLICY_INFORMATION PolicyInformation)
00252 {
00253     PLSA_DB_OBJECT DbObject;
00254     NTSTATUS Status;
00255 
00256     TRACE("LsarSetInformationPolicy(%p,0x%08x,%p)\n",
00257           PolicyHandle, InformationClass, PolicyInformation);
00258 
00259     if (PolicyInformation)
00260     {
00261         TRACE("*PolicyInformation %p\n", *PolicyInformation);
00262     }
00263 
00264     Status = LsapValidateDbObject(PolicyHandle,
00265                                   LsaDbPolicyObject,
00266                                   0, /* FIXME */
00267                                   &DbObject);
00268     if (!NT_SUCCESS(Status))
00269         return Status;
00270 
00271     switch (InformationClass)
00272     {
00273         case PolicyAuditEventsInformation:
00274             Status = STATUS_NOT_IMPLEMENTED;
00275             break;
00276 
00277         case PolicyPrimaryDomainInformation:
00278             Status = LsarSetPrimaryDomain(PolicyHandle,
00279                                           (PLSAPR_POLICY_PRIMARY_DOM_INFO)PolicyInformation);
00280             break;
00281 
00282         case PolicyAccountDomainInformation:
00283             Status = LsarSetAccountDomain(PolicyHandle,
00284                                           (PLSAPR_POLICY_ACCOUNT_DOM_INFO)PolicyInformation);
00285             break;
00286 
00287         case PolicyDnsDomainInformation:
00288             Status = LsarSetDnsDomain(PolicyHandle,
00289                                       (PLSAPR_POLICY_DNS_DOMAIN_INFO)PolicyInformation);
00290             break;
00291 
00292         case PolicyLsaServerRoleInformation:
00293             Status = STATUS_NOT_IMPLEMENTED;
00294             break;
00295 
00296         default:
00297             Status = STATUS_INVALID_PARAMETER;
00298             break;
00299     }
00300 
00301     return Status;
00302 }
00303 
00304 
00305 /* Function 9 */
00306 NTSTATUS WINAPI LsarClearAuditLog(
00307     LSAPR_HANDLE ObjectHandle)
00308 {
00309     /* Deprecated */
00310     return STATUS_NOT_IMPLEMENTED;
00311 }
00312 
00313 
00314 /* Function 10 */
00315 NTSTATUS WINAPI LsarCreateAccount(
00316     LSAPR_HANDLE PolicyHandle,
00317     PRPC_SID AccountSid,
00318     ACCESS_MASK DesiredAccess,
00319     LSAPR_HANDLE *AccountHandle)
00320 {
00321     PLSA_DB_OBJECT PolicyObject;
00322     PLSA_DB_OBJECT AccountsObject = NULL;
00323     PLSA_DB_OBJECT AccountObject = NULL;
00324     LPWSTR SidString = NULL;
00325     NTSTATUS Status = STATUS_SUCCESS;
00326 
00327     /* Validate the PolicyHandle */
00328     Status = LsapValidateDbObject(PolicyHandle,
00329                                   LsaDbPolicyObject,
00330                                   POLICY_CREATE_ACCOUNT,
00331                                   &PolicyObject);
00332     if (!NT_SUCCESS(Status))
00333     {
00334         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
00335         return Status;
00336     }
00337 
00338     /* Open the Accounts object */
00339     Status = LsapOpenDbObject(PolicyObject,
00340                               L"Accounts",
00341                               LsaDbContainerObject,
00342                               0,
00343                               &AccountsObject);
00344     if (!NT_SUCCESS(Status))
00345     {
00346         ERR("LsapCreateDbObject (Accounts) failed (Status 0x%08lx)\n", Status);
00347         goto done;
00348     }
00349 
00350     /* Create SID string */
00351     if (!ConvertSidToStringSid((PSID)AccountSid,
00352                                &SidString))
00353     {
00354         ERR("ConvertSidToStringSid failed\n");
00355         Status = STATUS_INVALID_PARAMETER;
00356         goto done;
00357     }
00358 
00359     /* Create the Account object */
00360     Status = LsapCreateDbObject(AccountsObject,
00361                                 SidString,
00362                                 LsaDbAccountObject,
00363                                 DesiredAccess,
00364                                 &AccountObject);
00365     if (!NT_SUCCESS(Status))
00366     {
00367         ERR("LsapCreateDbObject (Account) failed (Status 0x%08lx)\n", Status);
00368         goto done;
00369     }
00370 
00371     /* Set the Sid attribute */
00372     Status = LsapSetObjectAttribute(AccountObject,
00373                                     L"Sid",
00374                                     (PVOID)AccountSid,
00375                                     GetLengthSid(AccountSid));
00376 
00377 done:
00378     if (SidString != NULL)
00379         LocalFree(SidString);
00380 
00381     if (!NT_SUCCESS(Status))
00382     {
00383         if (AccountObject != NULL)
00384             LsapCloseDbObject(AccountObject);
00385     }
00386     else
00387     {
00388         *AccountHandle = (LSAPR_HANDLE)AccountObject;
00389     }
00390 
00391     if (AccountsObject != NULL)
00392         LsapCloseDbObject(AccountsObject);
00393 
00394     return STATUS_SUCCESS;
00395 }
00396 
00397 
00398 /* Function 11 */
00399 NTSTATUS WINAPI LsarEnumerateAccounts(
00400     LSAPR_HANDLE PolicyHandle,
00401     DWORD *EnumerationContext,
00402     PLSAPR_ACCOUNT_ENUM_BUFFER EnumerationBuffer,
00403     DWORD PreferedMaximumLength)
00404 {
00405     UNIMPLEMENTED;
00406     return STATUS_NOT_IMPLEMENTED;
00407 }
00408 
00409 
00410 /* Function 12 */
00411 NTSTATUS WINAPI LsarCreateTrustedDomain(
00412     LSAPR_HANDLE PolicyHandle,
00413     PLSAPR_TRUST_INFORMATION TrustedDomainInformation,
00414     ACCESS_MASK DesiredAccess,
00415     LSAPR_HANDLE *TrustedDomainHandle)
00416 {
00417     UNIMPLEMENTED;
00418     return STATUS_NOT_IMPLEMENTED;
00419 }
00420 
00421 
00422 /* Function 13 */
00423 NTSTATUS WINAPI LsarEnumerateTrustedDomains(
00424     LSAPR_HANDLE PolicyHandle,
00425     DWORD *EnumerationContext,
00426     PLSAPR_TRUSTED_ENUM_BUFFER EnumerationBuffer,
00427     DWORD PreferedMaximumLength)
00428 {
00429     UNIMPLEMENTED;
00430     return STATUS_NOT_IMPLEMENTED;
00431 }
00432 
00433 
00434 /* Function 14 */
00435 NTSTATUS WINAPI LsarLookupNames(
00436     LSAPR_HANDLE PolicyHandle,
00437     DWORD Count,
00438     PRPC_UNICODE_STRING Names,
00439     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
00440     PLSAPR_TRANSLATED_SIDS TranslatedSids,
00441     LSAP_LOOKUP_LEVEL LookupLevel,
00442     DWORD *MappedCount)
00443 {
00444     SID_IDENTIFIER_AUTHORITY IdentifierAuthority = {SECURITY_NT_AUTHORITY};
00445     static const UNICODE_STRING DomainName = RTL_CONSTANT_STRING(L"DOMAIN");
00446     PLSAPR_REFERENCED_DOMAIN_LIST OutputDomains = NULL;
00447     PLSA_TRANSLATED_SID OutputSids = NULL;
00448     ULONG OutputSidsLength;
00449     ULONG i;
00450     PSID Sid;
00451     ULONG SidLength;
00452     NTSTATUS Status;
00453 
00454     TRACE("LsarLookupNames(%p, %lu, %p, %p, %p, %d, %p)\n",
00455           PolicyHandle, Count, Names, ReferencedDomains, TranslatedSids,
00456           LookupLevel, MappedCount);
00457 
00458     TranslatedSids->Entries = Count;
00459     TranslatedSids->Sids = NULL;
00460     *ReferencedDomains = NULL;
00461 
00462     OutputSidsLength = Count * sizeof(LSA_TRANSLATED_SID);
00463     OutputSids = MIDL_user_allocate(OutputSidsLength);
00464     if (OutputSids == NULL)
00465     {
00466         return STATUS_INSUFFICIENT_RESOURCES;
00467     }
00468 
00469     RtlZeroMemory(OutputSids, OutputSidsLength);
00470 
00471     OutputDomains = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
00472     if (OutputDomains == NULL)
00473     {
00474         MIDL_user_free(OutputSids);
00475         return STATUS_INSUFFICIENT_RESOURCES;
00476     }
00477 
00478     OutputDomains->Entries = Count;
00479     OutputDomains->Domains = MIDL_user_allocate(Count * sizeof(LSA_TRUST_INFORMATION));
00480     if (OutputDomains->Domains == NULL)
00481     {
00482         MIDL_user_free(OutputDomains);
00483         MIDL_user_free(OutputSids);
00484         return STATUS_INSUFFICIENT_RESOURCES;
00485     }
00486 
00487     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
00488                                          2,
00489                                          SECURITY_BUILTIN_DOMAIN_RID,
00490                                          DOMAIN_ALIAS_RID_ADMINS,
00491                                          0, 0, 0, 0, 0, 0,
00492                                          &Sid);
00493     if (!NT_SUCCESS(Status))
00494     {
00495         MIDL_user_free(OutputDomains->Domains);
00496         MIDL_user_free(OutputDomains);
00497         MIDL_user_free(OutputSids);
00498         return Status;
00499     }
00500 
00501     SidLength = RtlLengthSid(Sid);
00502 
00503     for (i = 0; i < Count; i++)
00504     {
00505         OutputDomains->Domains[i].Sid = MIDL_user_allocate(SidLength);
00506         RtlCopyMemory(OutputDomains->Domains[i].Sid, Sid, SidLength);
00507 
00508         OutputDomains->Domains[i].Name.Buffer = MIDL_user_allocate(DomainName.MaximumLength);
00509         OutputDomains->Domains[i].Name.Length = DomainName.Length;
00510         OutputDomains->Domains[i].Name.MaximumLength = DomainName.MaximumLength;
00511         RtlCopyMemory(OutputDomains->Domains[i].Name.Buffer, DomainName.Buffer, DomainName.MaximumLength);
00512     }
00513 
00514     for (i = 0; i < Count; i++)
00515     {
00516         OutputSids[i].Use = SidTypeWellKnownGroup;
00517         OutputSids[i].RelativeId = DOMAIN_USER_RID_ADMIN; //DOMAIN_ALIAS_RID_ADMINS;
00518         OutputSids[i].DomainIndex = i;
00519     }
00520 
00521     *ReferencedDomains = OutputDomains;
00522 
00523     *MappedCount = Count;
00524 
00525     TranslatedSids->Entries = Count;
00526     TranslatedSids->Sids = OutputSids;
00527 
00528     return STATUS_SUCCESS;
00529 }
00530 
00531 
00532 /* Function 15 */
00533 NTSTATUS WINAPI LsarLookupSids(
00534     LSAPR_HANDLE PolicyHandle,
00535     PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
00536     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
00537     PLSAPR_TRANSLATED_NAMES TranslatedNames,
00538     LSAP_LOOKUP_LEVEL LookupLevel,
00539     DWORD *MappedCount)
00540 {
00541     SID_IDENTIFIER_AUTHORITY IdentifierAuthority = {SECURITY_NT_AUTHORITY};
00542     static const UNICODE_STRING DomainName = RTL_CONSTANT_STRING(L"DOMAIN");
00543     PLSAPR_REFERENCED_DOMAIN_LIST OutputDomains = NULL;
00544     PLSAPR_TRANSLATED_NAME OutputNames = NULL;
00545     ULONG OutputNamesLength;
00546     ULONG i;
00547     PSID Sid;
00548     ULONG SidLength;
00549     NTSTATUS Status;
00550 
00551     TRACE("LsarLookupSids(%p, %p, %p, %p, %d, %p)\n",
00552           PolicyHandle, SidEnumBuffer, ReferencedDomains, TranslatedNames,
00553           LookupLevel, MappedCount);
00554 
00555     TranslatedNames->Entries = SidEnumBuffer->Entries;
00556     TranslatedNames->Names = NULL;
00557     *ReferencedDomains = NULL;
00558 
00559     OutputNamesLength = SidEnumBuffer->Entries * sizeof(LSA_TRANSLATED_NAME);
00560     OutputNames = MIDL_user_allocate(OutputNamesLength);
00561     if (OutputNames == NULL)
00562     {
00563         return STATUS_INSUFFICIENT_RESOURCES;
00564     }
00565 
00566     RtlZeroMemory(OutputNames, OutputNamesLength);
00567 
00568     OutputDomains = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
00569     if (OutputDomains == NULL)
00570     {
00571         MIDL_user_free(OutputNames);
00572         return STATUS_INSUFFICIENT_RESOURCES;
00573     }
00574 
00575     OutputDomains->Entries = SidEnumBuffer->Entries;
00576     OutputDomains->Domains = MIDL_user_allocate(SidEnumBuffer->Entries * sizeof(LSA_TRUST_INFORMATION));
00577     if (OutputDomains->Domains == NULL)
00578     {
00579         MIDL_user_free(OutputDomains);
00580         MIDL_user_free(OutputNames);
00581         return STATUS_INSUFFICIENT_RESOURCES;
00582     }
00583 
00584     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
00585                                          2,
00586                                          SECURITY_BUILTIN_DOMAIN_RID,
00587                                          DOMAIN_ALIAS_RID_ADMINS,
00588                                          0, 0, 0, 0, 0, 0,
00589                                          &Sid);
00590     if (!NT_SUCCESS(Status))
00591     {
00592         MIDL_user_free(OutputDomains->Domains);
00593         MIDL_user_free(OutputDomains);
00594         MIDL_user_free(OutputNames);
00595         return Status;
00596     }
00597 
00598     SidLength = RtlLengthSid(Sid);
00599 
00600     for (i = 0; i < SidEnumBuffer->Entries; i++)
00601     {
00602         OutputDomains->Domains[i].Sid = MIDL_user_allocate(SidLength);
00603         RtlCopyMemory(OutputDomains->Domains[i].Sid, Sid, SidLength);
00604 
00605         OutputDomains->Domains[i].Name.Buffer = MIDL_user_allocate(DomainName.MaximumLength);
00606         OutputDomains->Domains[i].Name.Length = DomainName.Length;
00607         OutputDomains->Domains[i].Name.MaximumLength = DomainName.MaximumLength;
00608         RtlCopyMemory(OutputDomains->Domains[i].Name.Buffer, DomainName.Buffer, DomainName.MaximumLength);
00609     }
00610 
00611     Status = LsapLookupSids(SidEnumBuffer,
00612                             OutputNames);
00613 
00614     *ReferencedDomains = OutputDomains;
00615 
00616     *MappedCount = SidEnumBuffer->Entries;
00617 
00618     TranslatedNames->Entries = SidEnumBuffer->Entries;
00619     TranslatedNames->Names = OutputNames;
00620 
00621     return Status;
00622 }
00623 
00624 
00625 /* Function 16 */
00626 NTSTATUS WINAPI LsarCreateSecret(
00627     LSAPR_HANDLE PolicyHandle,
00628     PRPC_UNICODE_STRING SecretName,
00629     ACCESS_MASK DesiredAccess,
00630     LSAPR_HANDLE *SecretHandle)
00631 {
00632     UNIMPLEMENTED;
00633     return STATUS_NOT_IMPLEMENTED;
00634 }
00635 
00636 
00637 /* Function 17 */
00638 NTSTATUS WINAPI LsarOpenAccount(
00639     LSAPR_HANDLE PolicyHandle,
00640     PRPC_SID AccountSid,
00641     ACCESS_MASK DesiredAccess,
00642     LSAPR_HANDLE *AccountHandle)
00643 {
00644     PLSA_DB_OBJECT PolicyObject;
00645     PLSA_DB_OBJECT AccountsObject = NULL;
00646     PLSA_DB_OBJECT AccountObject = NULL;
00647     LPWSTR SidString = NULL;
00648     NTSTATUS Status = STATUS_SUCCESS;
00649 
00650     /* Validate the PolicyHandle */
00651     Status = LsapValidateDbObject(PolicyHandle,
00652                                   LsaDbPolicyObject,
00653                                   POLICY_CREATE_ACCOUNT,
00654                                   &PolicyObject);
00655     if (!NT_SUCCESS(Status))
00656     {
00657         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
00658         return Status;
00659     }
00660 
00661     /* Open the Accounts object */
00662     Status = LsapOpenDbObject(PolicyObject,
00663                               L"Accounts",
00664                               LsaDbContainerObject,
00665                               0,
00666                               &AccountsObject);
00667     if (!NT_SUCCESS(Status))
00668     {
00669         ERR("LsapCreateDbObject (Accounts) failed (Status 0x%08lx)\n", Status);
00670         goto done;
00671     }
00672 
00673     /* Create SID string */
00674     if (!ConvertSidToStringSid((PSID)AccountSid,
00675                                &SidString))
00676     {
00677         ERR("ConvertSidToStringSid failed\n");
00678         Status = STATUS_INVALID_PARAMETER;
00679         goto done;
00680     }
00681 
00682     /* Create the Account object */
00683     Status = LsapOpenDbObject(AccountsObject,
00684                               SidString,
00685                               LsaDbAccountObject,
00686                               DesiredAccess,
00687                               &AccountObject);
00688     if (!NT_SUCCESS(Status))
00689     {
00690         ERR("LsapOpenDbObject (Account) failed (Status 0x%08lx)\n", Status);
00691         goto done;
00692     }
00693 
00694     /* Set the Sid attribute */
00695     Status = LsapSetObjectAttribute(AccountObject,
00696                                     L"Sid",
00697                                     (PVOID)AccountSid,
00698                                     GetLengthSid(AccountSid));
00699 
00700 done:
00701     if (SidString != NULL)
00702         LocalFree(SidString);
00703 
00704     if (!NT_SUCCESS(Status))
00705     {
00706         if (AccountObject != NULL)
00707             LsapCloseDbObject(AccountObject);
00708     }
00709     else
00710     {
00711         *AccountHandle = (LSAPR_HANDLE)AccountObject;
00712     }
00713 
00714     if (AccountsObject != NULL)
00715         LsapCloseDbObject(AccountsObject);
00716 
00717     return STATUS_SUCCESS;
00718 }
00719 
00720 
00721 /* Function 18 */
00722 NTSTATUS WINAPI LsarEnumeratePrivilegesAccount(
00723     LSAPR_HANDLE AccountHandle,
00724     PLSAPR_PRIVILEGE_SET *Privileges)
00725 {
00726     PLSA_DB_OBJECT AccountObject;
00727     ULONG PrivilegeSetSize = 0;
00728     PLSAPR_PRIVILEGE_SET PrivilegeSet = NULL;
00729     NTSTATUS Status;
00730 
00731     *Privileges = NULL;
00732 
00733     /* Validate the AccountHandle */
00734     Status = LsapValidateDbObject(AccountHandle,
00735                                   LsaDbAccountObject,
00736                                   ACCOUNT_VIEW,
00737                                   &AccountObject);
00738     if (!NT_SUCCESS(Status))
00739     {
00740         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
00741         return Status;
00742     }
00743 
00744     /* Get the size of the privilege set */
00745     Status = LsapGetObjectAttribute(AccountObject,
00746                                     L"Privilgs",
00747                                     NULL,
00748                                     &PrivilegeSetSize);
00749     if (!NT_SUCCESS(Status))
00750         return Status;
00751 
00752     /* Allocate a buffer for the privilege set */
00753     PrivilegeSet = MIDL_user_allocate(PrivilegeSetSize);
00754     if (PrivilegeSet == NULL)
00755         return STATUS_NO_MEMORY;
00756 
00757     /* Get the privilege set */
00758     Status = LsapGetObjectAttribute(AccountObject,
00759                                     L"Privilgs",
00760                                     PrivilegeSet,
00761                                     &PrivilegeSetSize);
00762     if (!NT_SUCCESS(Status))
00763     {
00764         MIDL_user_free(PrivilegeSet);
00765         return Status;
00766     }
00767 
00768     /* Return a pointer to the privilege set */
00769     *Privileges = PrivilegeSet;
00770 
00771     return STATUS_SUCCESS;
00772 }
00773 
00774 
00775 /* Function 19 */
00776 NTSTATUS WINAPI LsarAddPrivilegesToAccount(
00777     LSAPR_HANDLE AccountHandle,
00778     PLSAPR_PRIVILEGE_SET Privileges)
00779 {
00780     PLSA_DB_OBJECT AccountObject;
00781     PPRIVILEGE_SET CurrentPrivileges = NULL;
00782     PPRIVILEGE_SET NewPrivileges = NULL;
00783     ULONG PrivilegeSetSize = 0;
00784     ULONG PrivilegeCount;
00785     ULONG i, j;
00786     BOOL bFound;
00787     NTSTATUS Status;
00788 
00789     /* Validate the AccountHandle */
00790     Status = LsapValidateDbObject(AccountHandle,
00791                                   LsaDbAccountObject,
00792                                   ACCOUNT_ADJUST_PRIVILEGES,
00793                                   &AccountObject);
00794     if (!NT_SUCCESS(Status))
00795     {
00796         ERR("LsapValidateDbObject returned 0x%08lx\n", Status);
00797         return Status;
00798     }
00799 
00800     Status = LsapGetObjectAttribute(AccountObject,
00801                                     L"Privilgs",
00802                                     NULL,
00803                                     &PrivilegeSetSize);
00804     if (!NT_SUCCESS(Status) || PrivilegeSetSize == 0)
00805     {
00806         /* The Privilgs attribute does not exist */
00807 
00808         PrivilegeSetSize = sizeof(PRIVILEGE_SET) +
00809                            (Privileges->PrivilegeCount - 1) * sizeof(LUID_AND_ATTRIBUTES);
00810         Status = LsapSetObjectAttribute(AccountObject,
00811                                         L"Privilgs",
00812                                         Privileges,
00813                                         PrivilegeSetSize);
00814     }
00815     else
00816     {
00817         /* The Privilgs attribute exists */
00818 
00819         /* Allocate memory for the stored privilege set */
00820         CurrentPrivileges = MIDL_user_allocate(PrivilegeSetSize);
00821         if (CurrentPrivileges == NULL)
00822             return STATUS_NO_MEMORY;
00823 
00824         /* Get the current privilege set */
00825         Status = LsapGetObjectAttribute(AccountObject,
00826                                         L"Privilgs",
00827                                         CurrentPrivileges,
00828                                         &PrivilegeSetSize);
00829         if (!NT_SUCCESS(Status))
00830         {
00831             TRACE("LsapGetObjectAttribute() failed (Status 0x%08lx)\n", Status);
00832             goto done;
00833         }
00834 
00835         PrivilegeCount = CurrentPrivileges->PrivilegeCount;
00836         TRACE("Current privilege count: %lu\n", PrivilegeCount);
00837 
00838         /* Calculate the number privileges in the combined privilege set */
00839         for (i = 0; i < Privileges->PrivilegeCount; i++)
00840         {
00841             bFound = FALSE;
00842             for (j = 0; j < CurrentPrivileges->PrivilegeCount; j++)
00843             {
00844                 if (RtlEqualLuid(&(Privileges->Privilege[i].Luid),
00845                                  &(CurrentPrivileges->Privilege[i].Luid)))
00846                 {
00847                     bFound = TRUE;
00848                     break;
00849                 }
00850             }
00851 
00852             if (bFound == FALSE)
00853             {
00854                 TRACE("Found new privilege\n");
00855                 PrivilegeCount++;
00856             }
00857         }
00858         TRACE("New privilege count: %lu\n", PrivilegeCount);
00859 
00860         /* Calculate the size of the new privilege set and allocate it */
00861         PrivilegeSetSize = sizeof(PRIVILEGE_SET) +
00862                            (PrivilegeCount - 1) * sizeof(LUID_AND_ATTRIBUTES);
00863         NewPrivileges = MIDL_user_allocate(PrivilegeSetSize);
00864         if (NewPrivileges == NULL)
00865         {
00866             Status = STATUS_NO_MEMORY;
00867             goto done;
00868         }
00869 
00870         /* Initialize the new privilege set */
00871         NewPrivileges->PrivilegeCount = PrivilegeCount;
00872         NewPrivileges->Control = 0;
00873 
00874         /* Copy all privileges from the current privilege set */
00875         RtlCopyLuidAndAttributesArray(CurrentPrivileges->PrivilegeCount,
00876                                       &(CurrentPrivileges->Privilege[0]),
00877                                       &(NewPrivileges->Privilege[0]));
00878 
00879         /* Add new privileges to the new privilege set */
00880         PrivilegeCount = CurrentPrivileges->PrivilegeCount;
00881         for (i = 0; i < Privileges->PrivilegeCount; i++)
00882         {
00883             bFound = FALSE;
00884             for (j = 0; j < CurrentPrivileges->PrivilegeCount; j++)
00885             {
00886                 if (RtlEqualLuid(&(Privileges->Privilege[i].Luid),
00887                                  &(CurrentPrivileges->Privilege[i].Luid)))
00888                 {
00889                     /* Overwrite attributes if a matching privilege was found */
00890                     NewPrivileges->Privilege[j].Attributes = Privileges->Privilege[i].Attributes;
00891 
00892                     bFound = TRUE;
00893                     break;
00894                 }
00895             }
00896 
00897             if (bFound == FALSE)
00898             {
00899                 /* Copy the new privilege */
00900                 RtlCopyLuidAndAttributesArray(1,
00901                                               (PLUID_AND_ATTRIBUTES)&(Privileges->Privilege[i]),
00902                                               &(NewPrivileges->Privilege[PrivilegeCount]));
00903                 PrivilegeCount++;
00904             }
00905         }
00906 
00907         /* Set the new priivliege set */
00908         Status = LsapSetObjectAttribute(AccountObject,
00909                                         L"Privilgs",
00910                                         NewPrivileges,
00911                                         PrivilegeSetSize);
00912     }
00913 
00914 done:
00915     if (CurrentPrivileges != NULL)
00916         MIDL_user_free(CurrentPrivileges);
00917 
00918     if (NewPrivileges != NULL)
00919         MIDL_user_free(NewPrivileges);
00920 
00921     return Status;
00922 }
00923 
00924 
00925 /* Function 20 */
00926 NTSTATUS WINAPI LsarRemovePrivilegesFromAccount(
00927     LSAPR_HANDLE AccountHandle,
00928     BOOL AllPrivileges,
00929     PLSAPR_PRIVILEGE_SET Privileges)
00930 {
00931     UNIMPLEMENTED;
00932     return STATUS_NOT_IMPLEMENTED;
00933 }
00934 
00935 
00936 /* Function 21 */
00937 NTSTATUS WINAPI LsarGetQuotasForAccount(
00938     LSAPR_HANDLE AccountHandle,
00939     PQUOTA_LIMITS QuotaLimits)
00940 {
00941     UNIMPLEMENTED;
00942     return STATUS_NOT_IMPLEMENTED;
00943 }
00944 
00945 
00946 /* Function 22 */
00947 NTSTATUS WINAPI LsarSetQuotasForAccount(
00948     LSAPR_HANDLE AccountHandle,
00949     PQUOTA_LIMITS QuotaLimits)
00950 {
00951     UNIMPLEMENTED;
00952     return STATUS_NOT_IMPLEMENTED;
00953 }
00954 
00955 
00956 /* Function 23 */
00957 NTSTATUS WINAPI LsarGetSystemAccessAccount(
00958     LSAPR_HANDLE AccountHandle,
00959     ACCESS_MASK *SystemAccess)
00960 {
00961     UNIMPLEMENTED;
00962     return STATUS_NOT_IMPLEMENTED;
00963 }
00964 
00965 
00966 /* Function 24 */
00967 NTSTATUS WINAPI LsarSetSystemAccessAccount(
00968     LSAPR_HANDLE AccountHandle,
00969     ACCESS_MASK SystemAccess)
00970 {
00971     UNIMPLEMENTED;
00972     return STATUS_NOT_IMPLEMENTED;
00973 }
00974 
00975 
00976 /* Function 25 */
00977 NTSTATUS WINAPI LsarOpenTrustedDomain(
00978     LSAPR_HANDLE PolicyHandle,
00979     PRPC_SID TrustedDomainSid,
00980     ACCESS_MASK DesiredAccess,
00981     LSAPR_HANDLE *TrustedDomainHandle)
00982 {
00983     UNIMPLEMENTED;
00984     return STATUS_NOT_IMPLEMENTED;
00985 }
00986 
00987 
00988 /* Function 26 */
00989 NTSTATUS WINAPI LsarQueryInfoTrustedDomain(
00990     LSAPR_HANDLE TrustedDomainHandle,
00991     TRUSTED_INFORMATION_CLASS InformationClass,
00992     PLSAPR_TRUSTED_DOMAIN_INFO *TrustedDomainInformation)
00993 {
00994     UNIMPLEMENTED;
00995     return STATUS_NOT_IMPLEMENTED;
00996 }
00997 
00998 
00999 /* Function 27 */
01000 NTSTATUS WINAPI LsarSetInformationTrustedDomain(
01001     LSAPR_HANDLE TrustedDomainHandle,
01002     TRUSTED_INFORMATION_CLASS InformationClass,
01003     PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation)
01004 {
01005     UNIMPLEMENTED;
01006     return STATUS_NOT_IMPLEMENTED;
01007 }
01008 
01009 
01010 /* Function 28 */
01011 NTSTATUS WINAPI LsarOpenSecret(
01012     LSAPR_HANDLE PolicyHandle,
01013     PRPC_UNICODE_STRING SecretName,
01014     ACCESS_MASK DesiredAccess,
01015     LSAPR_HANDLE *SecretHandle)
01016 {
01017     UNIMPLEMENTED;
01018     return STATUS_NOT_IMPLEMENTED;
01019 }
01020 
01021 
01022 /* Function 29 */
01023 NTSTATUS WINAPI LsarSetSecret(
01024     LSAPR_HANDLE *SecretHandle,
01025     PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue,
01026     PLSAPR_CR_CIPHER_VALUE EncryptedOldValue)
01027 {
01028     UNIMPLEMENTED;
01029     return STATUS_NOT_IMPLEMENTED;
01030 }
01031 
01032 
01033 /* Function 30 */
01034 NTSTATUS WINAPI LsarQuerySecret(
01035     LSAPR_HANDLE SecretHandle,
01036     PLSAPR_CR_CIPHER_VALUE *EncryptedCurrentValue,
01037     PLARGE_INTEGER CurrentValueSetTime,
01038     PLSAPR_CR_CIPHER_VALUE *EncryptedOldValue,
01039     PLARGE_INTEGER OldValueSetTime)
01040 {
01041     UNIMPLEMENTED;
01042     return STATUS_NOT_IMPLEMENTED;
01043 }
01044 
01045 
01046 /* Function 31 */
01047 NTSTATUS WINAPI LsarLookupPrivilegeValue(
01048     LSAPR_HANDLE PolicyHandle,
01049     PRPC_UNICODE_STRING Name,
01050     PLUID Value)
01051 {
01052     NTSTATUS Status;
01053 
01054     TRACE("LsarLookupPrivilegeValue(%p, %wZ, %p)\n",
01055           PolicyHandle, Name, Value);
01056 
01057     Status = LsapValidateDbObject(PolicyHandle,
01058                                   LsaDbPolicyObject,
01059                                   0, /* FIXME */
01060                                   NULL);
01061     if (!NT_SUCCESS(Status))
01062     {
01063         ERR("Invalid handle (Status %lx)\n", Status);
01064         return Status;
01065     }
01066 
01067     TRACE("Privilege: %wZ\n", Name);
01068 
01069     Status = LsarpLookupPrivilegeValue((PUNICODE_STRING)Name,
01070                                        Value);
01071 
01072     return Status;
01073 }
01074 
01075 
01076 /* Function 32 */
01077 NTSTATUS WINAPI LsarLookupPrivilegeName(
01078     LSAPR_HANDLE PolicyHandle,
01079     PLUID Value,
01080     PRPC_UNICODE_STRING *Name)
01081 {
01082     NTSTATUS Status;
01083 
01084     TRACE("LsarLookupPrivilegeName(%p, %p, %p)\n",
01085           PolicyHandle, Value, Name);
01086 
01087     Status = LsapValidateDbObject(PolicyHandle,
01088                                   LsaDbPolicyObject,
01089                                   0, /* FIXME */
01090                                   NULL);
01091     if (!NT_SUCCESS(Status))
01092     {
01093         ERR("Invalid handle\n");
01094         return Status;
01095     }
01096 
01097     Status = LsarpLookupPrivilegeName(Value, (PUNICODE_STRING*)Name);
01098 
01099     return Status;
01100 }
01101 
01102 
01103 /* Function 33 */
01104 NTSTATUS WINAPI LsarLookupPrivilegeDisplayName(
01105     LSAPR_HANDLE PolicyHandle,
01106     PRPC_UNICODE_STRING Name,
01107     USHORT ClientLanguage,
01108     USHORT ClientSystemDefaultLanguage,
01109     PRPC_UNICODE_STRING *DisplayName,
01110     USHORT *LanguageReturned)
01111 {
01112     UNIMPLEMENTED;
01113     return STATUS_NOT_IMPLEMENTED;
01114 }
01115 
01116 
01117 /* Function 34 */
01118 NTSTATUS WINAPI LsarDeleteObject(
01119     LSAPR_HANDLE *ObjectHandle)
01120 {
01121     UNIMPLEMENTED;
01122     return STATUS_NOT_IMPLEMENTED;
01123 }
01124 
01125 
01126 /* Function 35 */
01127 NTSTATUS WINAPI LsarEnumerateAccountsWithUserRight(
01128     LSAPR_HANDLE PolicyHandle,
01129     PRPC_UNICODE_STRING UserRight,
01130     PLSAPR_ACCOUNT_ENUM_BUFFER EnumerationBuffer)
01131 {
01132     UNIMPLEMENTED;
01133     return STATUS_NOT_IMPLEMENTED;
01134 }
01135 
01136 
01137 /* Function 36 */
01138 NTSTATUS WINAPI LsarEnmuerateAccountRights(
01139     LSAPR_HANDLE PolicyHandle,
01140     PRPC_SID AccountSid,
01141     PLSAPR_USER_RIGHT_SET UserRights)
01142 {
01143     PLSA_DB_OBJECT PolicyObject;
01144     NTSTATUS Status;
01145 
01146     FIXME("(%p,%p,%p) stub\n", PolicyHandle, AccountSid, UserRights);
01147 
01148     Status = LsapValidateDbObject(PolicyHandle,
01149                                   LsaDbPolicyObject,
01150                                   0, /* FIXME */
01151                                   &PolicyObject);
01152     if (!NT_SUCCESS(Status))
01153         return Status;
01154 
01155     UserRights->Entries = 0;
01156     UserRights->UserRights = NULL;
01157     return STATUS_OBJECT_NAME_NOT_FOUND;
01158 }
01159 
01160 
01161 /* Function 37 */
01162 NTSTATUS WINAPI LsarAddAccountRights(
01163     LSAPR_HANDLE PolicyHandle,
01164     PRPC_SID AccountSid,
01165     PLSAPR_USER_RIGHT_SET UserRights)
01166 {
01167     UNIMPLEMENTED;
01168     return STATUS_NOT_IMPLEMENTED;
01169 }
01170 
01171 
01172 /* Function 38 */
01173 NTSTATUS WINAPI LsarRemoveAccountRights(
01174     LSAPR_HANDLE PolicyHandle,
01175     PRPC_SID AccountSid,
01176     BOOL AllRights,
01177     PLSAPR_USER_RIGHT_SET UserRights)
01178 {
01179     UNIMPLEMENTED;
01180     return STATUS_NOT_IMPLEMENTED;
01181 }
01182 
01183 
01184 /* Function 39 */
01185 NTSTATUS WINAPI LsarQueryTrustedDomainInfo(
01186     LSAPR_HANDLE PolicyHandle,
01187     PRPC_SID TrustedDomainSid,
01188     TRUSTED_INFORMATION_CLASS InformationClass,
01189     PLSAPR_TRUSTED_DOMAIN_INFO *TrustedDomainInformation)
01190 {
01191     UNIMPLEMENTED;
01192     return STATUS_NOT_IMPLEMENTED;
01193 }
01194 
01195 
01196 /* Function 40 */
01197 NTSTATUS WINAPI LsarSetTrustedDomainInfo(
01198     LSAPR_HANDLE PolicyHandle,
01199     PRPC_SID TrustedDomainSid,
01200     TRUSTED_INFORMATION_CLASS InformationClass,
01201     PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation)
01202 {
01203     UNIMPLEMENTED;
01204     return STATUS_NOT_IMPLEMENTED;
01205 }
01206 
01207 
01208 /* Function 41 */
01209 NTSTATUS WINAPI LsarDeleteTrustedDomain(
01210     LSAPR_HANDLE PolicyHandle,
01211     PRPC_SID TrustedDomainSid)
01212 {
01213     UNIMPLEMENTED;
01214     return STATUS_NOT_IMPLEMENTED;
01215 }
01216 
01217 
01218 /* Function 42 */
01219 NTSTATUS WINAPI LsarStorePrivateData(
01220     LSAPR_HANDLE PolicyHandle,
01221     PRPC_UNICODE_STRING KeyName,
01222     PLSAPR_CR_CIPHER_VALUE EncryptedData)
01223 {
01224     UNIMPLEMENTED;
01225     return STATUS_NOT_IMPLEMENTED;
01226 }
01227 
01228 
01229 /* Function 43 */
01230 NTSTATUS WINAPI LsarRetrievePrivateData(
01231     LSAPR_HANDLE PolicyHandle,
01232     PRPC_UNICODE_STRING KeyName,
01233     PLSAPR_CR_CIPHER_VALUE *EncryptedData)
01234 {
01235     UNIMPLEMENTED;
01236     return STATUS_NOT_IMPLEMENTED;
01237 }
01238 
01239 
01240 /* Function 44 */
01241 NTSTATUS WINAPI LsarOpenPolicy2(
01242     LPWSTR SystemName,
01243     PLSAPR_OBJECT_ATTRIBUTES ObjectAttributes,
01244     ACCESS_MASK DesiredAccess,
01245     LSAPR_HANDLE *PolicyHandle)
01246 {
01247     UNIMPLEMENTED;
01248     return STATUS_NOT_IMPLEMENTED;
01249 }
01250 
01251 
01252 /* Function 45 */
01253 NTSTATUS WINAPI LsarGetUserName(
01254     LPWSTR SystemName,
01255     PRPC_UNICODE_STRING *UserName,
01256     PRPC_UNICODE_STRING *DomainName)
01257 {
01258     UNIMPLEMENTED;
01259     return STATUS_NOT_IMPLEMENTED;
01260 }
01261 
01262 
01263 /* Function 46 */
01264 NTSTATUS WINAPI LsarQueryInformationPolicy2(
01265     LSAPR_HANDLE PolicyHandle,
01266     POLICY_INFORMATION_CLASS InformationClass,
01267     unsigned long *PolicyInformation)
01268 {
01269     UNIMPLEMENTED;
01270     return STATUS_NOT_IMPLEMENTED;
01271 }
01272 
01273 
01274 /* Function 47 */
01275 NTSTATUS WINAPI LsarSetInformationPolicy2(
01276     LSAPR_HANDLE PolicyHandle,
01277     POLICY_INFORMATION_CLASS InformationClass,
01278     unsigned long PolicyInformation)
01279 {
01280     UNIMPLEMENTED;
01281     return STATUS_NOT_IMPLEMENTED;
01282 }
01283 
01284 
01285 /* Function 48 */
01286 NTSTATUS WINAPI LsarQueryTrustedDomainInfoByName(
01287     LSAPR_HANDLE PolicyHandle,
01288     PRPC_UNICODE_STRING TrustedDomainName,
01289     POLICY_INFORMATION_CLASS InformationClass,
01290     unsigned long *PolicyInformation)
01291 {
01292     UNIMPLEMENTED;
01293     return STATUS_NOT_IMPLEMENTED;
01294 }
01295 
01296 
01297 /* Function 49 */
01298 NTSTATUS WINAPI LsarSetTrustedDomainInfoByName(
01299     LSAPR_HANDLE PolicyHandle,
01300     PRPC_UNICODE_STRING TrustedDomainName,
01301     POLICY_INFORMATION_CLASS InformationClass,
01302     unsigned long PolicyInformation)
01303 {
01304     UNIMPLEMENTED;
01305     return STATUS_NOT_IMPLEMENTED;
01306 }
01307 
01308 
01309 /* Function 50 */
01310 NTSTATUS WINAPI LsarEnumerateTrustedDomainsEx(
01311     LSAPR_HANDLE PolicyHandle,
01312     DWORD *EnumerationContext,
01313     PLSAPR_TRUSTED_ENUM_BUFFER_EX EnumerationBuffer,
01314     DWORD PreferedMaximumLength)
01315 {
01316     UNIMPLEMENTED;
01317     return STATUS_NOT_IMPLEMENTED;
01318 }
01319 
01320 
01321 /* Function 51 */
01322 NTSTATUS WINAPI LsarCreateTrustedDomainEx(
01323     LSAPR_HANDLE PolicyHandle,
01324     PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
01325     PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION AuthentificationInformation,
01326     ACCESS_MASK DesiredAccess,
01327     LSAPR_HANDLE *TrustedDomainHandle)
01328 {
01329     UNIMPLEMENTED;
01330     return STATUS_NOT_IMPLEMENTED;
01331 }
01332 
01333 
01334 /* Function 52 */
01335 NTSTATUS WINAPI LsarSetPolicyReplicationHandle(
01336     PLSAPR_HANDLE PolicyHandle)
01337 {
01338     /* Deprecated */
01339     return STATUS_NOT_IMPLEMENTED;
01340 }
01341 
01342 
01343 /* Function 53 */
01344 NTSTATUS WINAPI LsarQueryDomainInformationPolicy(
01345     LSAPR_HANDLE PolicyHandle,
01346     POLICY_INFORMATION_CLASS InformationClass,
01347     unsigned long *PolicyInformation)
01348 {
01349     UNIMPLEMENTED;
01350     return STATUS_NOT_IMPLEMENTED;
01351 }
01352 
01353 
01354 /* Function 54 */
01355 NTSTATUS WINAPI LsarSetDomainInformationPolicy(
01356     LSAPR_HANDLE PolicyHandle,
01357     POLICY_INFORMATION_CLASS InformationClass,
01358     unsigned long PolicyInformation)
01359 {
01360     UNIMPLEMENTED;
01361     return STATUS_NOT_IMPLEMENTED;
01362 }
01363 
01364 
01365 /* Function 55 */
01366 NTSTATUS WINAPI LsarOpenTrustedDomainByName(
01367     LSAPR_HANDLE PolicyHandle,
01368     PRPC_UNICODE_STRING TrustedDomainName,
01369     ACCESS_MASK DesiredAccess,
01370     LSAPR_HANDLE *TrustedDomainHandle)
01371 {
01372     UNIMPLEMENTED;
01373     return STATUS_NOT_IMPLEMENTED;
01374 }
01375 
01376 
01377 /* Function 56 */
01378 NTSTATUS WINAPI LsarTestCall(
01379     handle_t hBinding)
01380 {
01381     UNIMPLEMENTED;
01382     return STATUS_NOT_IMPLEMENTED;
01383 }
01384 
01385 
01386 /* Function 57 */
01387 NTSTATUS WINAPI LsarLookupSids2(
01388     LSAPR_HANDLE PolicyHandle,
01389     PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
01390     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
01391     PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,
01392     LSAP_LOOKUP_LEVEL LookupLevel,
01393     DWORD *MappedCount,
01394     DWORD LookupOptions,
01395     DWORD ClientRevision)
01396 {
01397     UNIMPLEMENTED;
01398     return STATUS_NOT_IMPLEMENTED;
01399 }
01400 
01401 
01402 /* Function 58 */
01403 NTSTATUS WINAPI LsarLookupNames2(
01404     LSAPR_HANDLE PolicyHandle,
01405     DWORD Count,
01406     PRPC_UNICODE_STRING Names,
01407     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
01408     PLSAPR_TRANSLATED_SIDS_EX TranslatedSids,
01409     LSAP_LOOKUP_LEVEL LookupLevel,
01410     DWORD *MappedCount,
01411     DWORD LookupOptions,
01412     DWORD ClientRevision)
01413 {
01414     UNIMPLEMENTED;
01415     return STATUS_NOT_IMPLEMENTED;
01416 }
01417 
01418 
01419 /* Function 59 */
01420 NTSTATUS WINAPI LsarCreateTrustedDomainEx2(
01421     LSAPR_HANDLE PolicyHandle,
01422     PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
01423     PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION_INTERNAL AuthentificationInformation,
01424     ACCESS_MASK DesiredAccess,
01425     LSAPR_HANDLE *TrustedDomainHandle)
01426 {
01427     UNIMPLEMENTED;
01428     return STATUS_NOT_IMPLEMENTED;
01429 }
01430 
01431 
01432 /* Function 60 */
01433 NTSTATUS WINAPI CredrWrite(
01434     handle_t hBinding)
01435 {
01436     UNIMPLEMENTED;
01437     return STATUS_NOT_IMPLEMENTED;
01438 }
01439 
01440 
01441 /* Function 61 */
01442 NTSTATUS WINAPI CredrRead(
01443     handle_t hBinding)
01444 {
01445     UNIMPLEMENTED;
01446     return STATUS_NOT_IMPLEMENTED;
01447 }
01448 
01449 
01450 /* Function 62 */
01451 NTSTATUS WINAPI CredrEnumerate(
01452     handle_t hBinding)
01453 {
01454     UNIMPLEMENTED;
01455     return STATUS_NOT_IMPLEMENTED;
01456 }
01457 
01458 
01459 /* Function 63 */
01460 NTSTATUS WINAPI CredrWriteDomainCredentials(
01461     handle_t hBinding)
01462 {
01463     UNIMPLEMENTED;
01464     return STATUS_NOT_IMPLEMENTED;
01465 }
01466 
01467 
01468 /* Function 64 */
01469 NTSTATUS WINAPI CredrReadDomainCredentials(
01470     handle_t hBinding)
01471 {
01472     UNIMPLEMENTED;
01473     return STATUS_NOT_IMPLEMENTED;
01474 }
01475 
01476 
01477 /* Function 65 */
01478 NTSTATUS WINAPI CredrDelete(
01479     handle_t hBinding)
01480 {
01481     UNIMPLEMENTED;
01482     return STATUS_NOT_IMPLEMENTED;
01483 }
01484 
01485 
01486 /* Function 66 */
01487 NTSTATUS WINAPI CredrGetTargetInfo(
01488     handle_t hBinding)
01489 {
01490     UNIMPLEMENTED;
01491     return STATUS_NOT_IMPLEMENTED;
01492 }
01493 
01494 
01495 /* Function 67 */
01496 NTSTATUS WINAPI CredrProfileLoaded(
01497     handle_t hBinding)
01498 {
01499     UNIMPLEMENTED;
01500     return STATUS_NOT_IMPLEMENTED;
01501 }
01502 
01503 
01504 /* Function 68 */
01505 NTSTATUS WINAPI LsarLookupNames3(
01506     LSAPR_HANDLE PolicyHandle,
01507     DWORD Count,
01508     PRPC_UNICODE_STRING Names,
01509     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
01510     PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,
01511     LSAP_LOOKUP_LEVEL LookupLevel,
01512     DWORD *MappedCount,
01513     DWORD LookupOptions,
01514     DWORD ClientRevision)
01515 {
01516     SID_IDENTIFIER_AUTHORITY IdentifierAuthority = {SECURITY_NT_AUTHORITY};
01517     static const UNICODE_STRING DomainName = RTL_CONSTANT_STRING(L"DOMAIN");
01518     PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer = NULL;
01519     PLSAPR_TRANSLATED_SID_EX2 SidsBuffer = NULL;
01520     ULONG SidsBufferLength;
01521     ULONG DomainSidLength;
01522     ULONG AccountSidLength;
01523     PSID DomainSid;
01524     PSID AccountSid;
01525     ULONG i;
01526     NTSTATUS Status;
01527 
01528     TRACE("LsarLookupNames3(%p, %lu, %p, %p, %p, %d, %p, %lu, %lu)\n",
01529           PolicyHandle, Count, Names, ReferencedDomains, TranslatedSids,
01530           LookupLevel, MappedCount, LookupOptions, ClientRevision);
01531 
01532     if (Count == 0)
01533         return STATUS_NONE_MAPPED;
01534 
01535     TranslatedSids->Entries = Count;
01536     TranslatedSids->Sids = NULL;
01537     *ReferencedDomains = NULL;
01538 
01539     SidsBufferLength = Count * sizeof(LSAPR_TRANSLATED_SID_EX2);
01540     SidsBuffer = MIDL_user_allocate(SidsBufferLength);
01541     if (SidsBuffer == NULL)
01542         return STATUS_INSUFFICIENT_RESOURCES;
01543 
01544     for (i = 0; i < Count; i++)
01545     {
01546         SidsBuffer[i].Use = SidTypeUser;
01547         SidsBuffer[i].Sid = NULL;
01548         SidsBuffer[i].DomainIndex = -1;
01549         SidsBuffer[i].Flags = 0;
01550     }
01551 
01552     DomainsBuffer = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
01553     if (DomainsBuffer == NULL)
01554     {
01555         MIDL_user_free(SidsBuffer);
01556         return STATUS_INSUFFICIENT_RESOURCES;
01557     }
01558 
01559     DomainsBuffer->Entries = Count;
01560     DomainsBuffer->Domains = MIDL_user_allocate(Count * sizeof(LSA_TRUST_INFORMATION));
01561     if (DomainsBuffer->Domains == NULL)
01562     {
01563         MIDL_user_free(DomainsBuffer);
01564         MIDL_user_free(SidsBuffer);
01565         return STATUS_INSUFFICIENT_RESOURCES;
01566     }
01567 
01568     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
01569                                          2,
01570                                          SECURITY_BUILTIN_DOMAIN_RID,
01571                                          DOMAIN_ALIAS_RID_ADMINS,
01572                                          0, 0, 0, 0, 0, 0,
01573                                          &DomainSid);
01574     if (!NT_SUCCESS(Status))
01575     {
01576         MIDL_user_free(DomainsBuffer->Domains);
01577         MIDL_user_free(DomainsBuffer);
01578         MIDL_user_free(SidsBuffer);
01579         return Status;
01580     }
01581 
01582     DomainSidLength = RtlLengthSid(DomainSid);
01583 
01584     for (i = 0; i < Count; i++)
01585     {
01586         DomainsBuffer->Domains[i].Sid = MIDL_user_allocate(DomainSidLength);
01587         RtlCopyMemory(DomainsBuffer->Domains[i].Sid,
01588                       DomainSid,
01589                       DomainSidLength);
01590 
01591         DomainsBuffer->Domains[i].Name.Buffer = MIDL_user_allocate(DomainName.MaximumLength);
01592         DomainsBuffer->Domains[i].Name.Length = DomainName.Length;
01593         DomainsBuffer->Domains[i].Name.MaximumLength = DomainName.MaximumLength;
01594         RtlCopyMemory(DomainsBuffer->Domains[i].Name.Buffer,
01595                       DomainName.Buffer,
01596                       DomainName.MaximumLength);
01597     }
01598 
01599     Status = RtlAllocateAndInitializeSid(&IdentifierAuthority,
01600                                          3,
01601                                          SECURITY_BUILTIN_DOMAIN_RID,
01602                                          DOMAIN_ALIAS_RID_ADMINS,
01603                                          DOMAIN_USER_RID_ADMIN,
01604                                          0, 0, 0, 0, 0,
01605                                          &AccountSid);
01606     if (!NT_SUCCESS(Status))
01607     {
01608         MIDL_user_free(DomainsBuffer->Domains);
01609         MIDL_user_free(DomainsBuffer);
01610         MIDL_user_free(SidsBuffer);
01611         return Status;
01612     }
01613 
01614     AccountSidLength = RtlLengthSid(AccountSid);
01615 
01616     for (i = 0; i < Count; i++)
01617     {
01618         SidsBuffer[i].Use = SidTypeWellKnownGroup;
01619         SidsBuffer[i].Sid = MIDL_user_allocate(AccountSidLength);
01620 
01621         RtlCopyMemory(SidsBuffer[i].Sid,
01622                       AccountSid,
01623                       AccountSidLength);
01624 
01625         SidsBuffer[i].DomainIndex = i;
01626         SidsBuffer[i].Flags = 0;
01627     }
01628 
01629     *ReferencedDomains = DomainsBuffer;
01630     *MappedCount = Count;
01631 
01632     TranslatedSids->Entries = Count;
01633     TranslatedSids->Sids = SidsBuffer;
01634 
01635     return STATUS_SUCCESS;
01636 }
01637 
01638 
01639 /* Function 69 */
01640 NTSTATUS WINAPI CredrGetSessionTypes(
01641     handle_t hBinding)
01642 {
01643     UNIMPLEMENTED;
01644     return STATUS_NOT_IMPLEMENTED;
01645 }
01646 
01647 
01648 /* Function 70 */
01649 NTSTATUS WINAPI LsarRegisterAuditEvent(
01650     handle_t hBinding)
01651 {
01652     UNIMPLEMENTED;
01653     return STATUS_NOT_IMPLEMENTED;
01654 }
01655 
01656 
01657 /* Function 71 */
01658 NTSTATUS WINAPI LsarGenAuditEvent(
01659     handle_t hBinding)
01660 {
01661     UNIMPLEMENTED;
01662     return STATUS_NOT_IMPLEMENTED;
01663 }
01664 
01665 
01666 /* Function 72 */
01667 NTSTATUS WINAPI LsarUnregisterAuditEvent(
01668     handle_t hBinding)
01669 {
01670     UNIMPLEMENTED;
01671     return STATUS_NOT_IMPLEMENTED;
01672 }
01673 
01674 
01675 /* Function 73 */
01676 NTSTATUS WINAPI LsarQueryForestTrustInformation(
01677     LSAPR_HANDLE PolicyHandle,
01678     PLSA_UNICODE_STRING TrustedDomainName,
01679     LSA_FOREST_TRUST_RECORD_TYPE HighestRecordType,
01680     PLSA_FOREST_TRUST_INFORMATION *ForestTrustInfo)
01681 {
01682     UNIMPLEMENTED;
01683     return STATUS_NOT_IMPLEMENTED;
01684 }
01685 
01686 
01687 /* Function 74 */
01688 NTSTATUS WINAPI LsarSetForestTrustInformation(
01689     LSAPR_HANDLE PolicyHandle,
01690     PLSA_UNICODE_STRING TrustedDomainName,
01691     LSA_FOREST_TRUST_RECORD_TYPE HighestRecordType,
01692     PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
01693     BOOL CheckOnly,
01694     PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
01695 {
01696     UNIMPLEMENTED;
01697     return STATUS_NOT_IMPLEMENTED;
01698 }
01699 
01700 
01701 /* Function 75 */
01702 NTSTATUS WINAPI CredrRename(
01703     handle_t hBinding)
01704 {
01705     UNIMPLEMENTED;
01706     return STATUS_NOT_IMPLEMENTED;
01707 }
01708 
01709 
01710 /* Function 76 */
01711 NTSTATUS WINAPI LsarLookupSids3(
01712     LSAPR_HANDLE PolicyHandle,
01713     PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
01714     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
01715     PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,
01716     LSAP_LOOKUP_LEVEL LookupLevel,
01717     DWORD *MappedCount,
01718     DWORD LookupOptions,
01719     DWORD ClientRevision)
01720 {
01721     UNIMPLEMENTED;
01722     return STATUS_NOT_IMPLEMENTED;
01723 }
01724 
01725 
01726 /* Function 77 */
01727 NTSTATUS WINAPI LsarLookupNames4(
01728     handle_t RpcHandle,
01729     DWORD Count,
01730     PRPC_UNICODE_STRING Names,
01731     PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
01732     PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,
01733     LSAP_LOOKUP_LEVEL LookupLevel,
01734     DWORD *MappedCount,
01735     DWORD LookupOptions,
01736     DWORD ClientRevision)
01737 {
01738     UNIMPLEMENTED;
01739     return STATUS_NOT_IMPLEMENTED;
01740 }
01741 
01742 
01743 /* Function 78 */
01744 NTSTATUS WINAPI LsarOpenPolicySce(
01745     handle_t hBinding)
01746 {
01747     UNIMPLEMENTED;
01748     return STATUS_NOT_IMPLEMENTED;
01749 }
01750 
01751 
01752 /* Function 79 */
01753 NTSTATUS WINAPI LsarAdtRegisterSecurityEventSource(
01754     handle_t hBinding)
01755 {
01756     UNIMPLEMENTED;
01757     return STATUS_NOT_IMPLEMENTED;
01758 }
01759 
01760 
01761 /* Function 80 */
01762 NTSTATUS WINAPI LsarAdtUnregisterSecurityEventSource(
01763     handle_t hBinding)
01764 {
01765     UNIMPLEMENTED;
01766     return STATUS_NOT_IMPLEMENTED;
01767 }
01768 
01769 
01770 /* Function 81 */
01771 NTSTATUS WINAPI LsarAdtReportSecurityEvent(
01772     handle_t hBinding)
01773 {
01774     UNIMPLEMENTED;
01775     return STATUS_NOT_IMPLEMENTED;
01776 }
01777 
01778 
01779 /* Function 82 */
01780 NTSTATUS WINAPI CredrFindBestCredential(
01781     handle_t hBinding)
01782 {
01783     UNIMPLEMENTED;
01784     return STATUS_NOT_IMPLEMENTED;
01785 }
01786 
01787 
01788 /* Function 83 */
01789 NTSTATUS WINAPI LsarSetAuditPolicy(
01790     handle_t hBinding)
01791 {
01792     UNIMPLEMENTED;
01793     return STATUS_NOT_IMPLEMENTED;
01794 }
01795 
01796 
01797 /* Function 84 */
01798 NTSTATUS WINAPI LsarQueryAuditPolicy(
01799     handle_t hBinding)
01800 {
01801     UNIMPLEMENTED;
01802     return STATUS_NOT_IMPLEMENTED;
01803 }
01804 
01805 
01806 /* Function 85 */
01807 NTSTATUS WINAPI LsarEnumerateAuditPolicy(
01808     handle_t hBinding)
01809 {
01810     UNIMPLEMENTED;
01811     return STATUS_NOT_IMPLEMENTED;
01812 }
01813 
01814 
01815 /* Function 86 */
01816 NTSTATUS WINAPI LsarEnumerateAuditCategories(
01817     handle_t hBinding)
01818 {
01819     UNIMPLEMENTED;
01820     return STATUS_NOT_IMPLEMENTED;
01821 }
01822 
01823 
01824 /* Function 87 */
01825 NTSTATUS WINAPI LsarEnumerateAuditSubCategories(
01826     handle_t hBinding)
01827 {
01828     UNIMPLEMENTED;
01829     return STATUS_NOT_IMPLEMENTED;
01830 }
01831 
01832 
01833 /* Function 88 */
01834 NTSTATUS WINAPI LsarLookupAuditCategoryName(
01835     handle_t hBinding)
01836 {
01837     UNIMPLEMENTED;
01838     return STATUS_NOT_IMPLEMENTED;
01839 }
01840 
01841 
01842 /* Function 89 */
01843 NTSTATUS WINAPI LsarLookupAuditSubCategoryName(
01844     handle_t hBinding)
01845 {
01846     UNIMPLEMENTED;
01847     return STATUS_NOT_IMPLEMENTED;
01848 }
01849 
01850 
01851 /* Function 90 */
01852 NTSTATUS WINAPI LsarSetAuditSecurity(
01853     handle_t hBinding)
01854 {
01855     UNIMPLEMENTED;
01856     return STATUS_NOT_IMPLEMENTED;
01857 }
01858 
01859 
01860 /* Function 91 */
01861 NTSTATUS WINAPI LsarQueryAuditSecurity(
01862     handle_t hBinding)
01863 {
01864     UNIMPLEMENTED;
01865     return STATUS_NOT_IMPLEMENTED;
01866 }
01867 
01868 
01869 /* Function 92 */
01870 NTSTATUS WINAPI CredReadByTokenHandle(
01871     handle_t hBinding)
01872 {
01873     UNIMPLEMENTED;
01874     return STATUS_NOT_IMPLEMENTED;
01875 }
01876 
01877 
01878 /* Function 93 */
01879 NTSTATUS WINAPI CredrRestoreCredentials(
01880     handle_t hBinding)
01881 {
01882     UNIMPLEMENTED;
01883     return STATUS_NOT_IMPLEMENTED;
01884 }
01885 
01886 
01887 /* Function 94 */
01888 NTSTATUS WINAPI CredrBackupCredentials(
01889     handle_t hBinding)
01890 {
01891     UNIMPLEMENTED;
01892     return STATUS_NOT_IMPLEMENTED;
01893 }
01894 
01895 /* EOF */
Generated on Sat May 26 2012 04:23:10 for ReactOS by
1.7.6.1