| /* |
| * Implementation of the Local Security Authority API |
| * |
| * Copyright 1999 Juergen Schmied |
| * Copyright 2002 Andriy Palamarchuk |
| * Copyright 2004 Mike McCormack |
| * Copyright 2005 Hans Leidekker |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include <stdarg.h> |
| |
| #include "ntstatus.h" |
| #define WIN32_NO_STATUS |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winreg.h" |
| #include "winternl.h" |
| #include "advapi32_misc.h" |
| |
| #include "wine/debug.h" |
| #include "wine/unicode.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(advapi); |
| |
| #define ADVAPI_ForceLocalComputer(ServerName, FailureCode) \ |
| if (!ADVAPI_IsLocalComputer(ServerName)) \ |
| { \ |
| FIXME("Action Implemented for local computer only. " \ |
| "Requested for server %s\n", debugstr_w(ServerName)); \ |
| return FailureCode; \ |
| } |
| |
| static void dumpLsaAttributes(const LSA_OBJECT_ATTRIBUTES *oa) |
| { |
| if (oa) |
| { |
| TRACE("\n\tlength=%u, rootdir=%p, objectname=%s\n\tattr=0x%08x, sid=%s qos=%p\n", |
| oa->Length, oa->RootDirectory, |
| oa->ObjectName?debugstr_w(oa->ObjectName->Buffer):"null", |
| oa->Attributes, debugstr_sid(oa->SecurityDescriptor), |
| oa->SecurityQualityOfService); |
| } |
| } |
| |
| static void* ADVAPI_GetDomainName(unsigned sz, unsigned ofs) |
| { |
| HKEY key; |
| LONG ret; |
| BYTE* ptr = NULL; |
| UNICODE_STRING* ustr; |
| |
| static const WCHAR wVNETSUP[] = { |
| 'S','y','s','t','e','m','\\', |
| 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\', |
| 'S','e','r','v','i','c','e','s','\\', |
| 'V','x','D','\\','V','N','E','T','S','U','P','\0'}; |
| |
| ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, wVNETSUP, 0, KEY_READ, &key); |
| if (ret == ERROR_SUCCESS) |
| { |
| DWORD size = 0; |
| static const WCHAR wg[] = { 'W','o','r','k','g','r','o','u','p',0 }; |
| |
| ret = RegQueryValueExW(key, wg, NULL, NULL, NULL, &size); |
| if (ret == ERROR_MORE_DATA || ret == ERROR_SUCCESS) |
| { |
| ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz + size); |
| if (!ptr) return NULL; |
| ustr = (UNICODE_STRING*)(ptr + ofs); |
| ustr->MaximumLength = size; |
| ustr->Buffer = (WCHAR*)(ptr + sz); |
| ret = RegQueryValueExW(key, wg, NULL, NULL, (LPBYTE)ustr->Buffer, &size); |
| if (ret != ERROR_SUCCESS) |
| { |
| HeapFree(GetProcessHeap(), 0, ptr); |
| ptr = NULL; |
| } |
| else ustr->Length = size - sizeof(WCHAR); |
| } |
| RegCloseKey(key); |
| } |
| if (!ptr) |
| { |
| static const WCHAR wDomain[] = {'D','O','M','A','I','N','\0'}; |
| ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, |
| sz + sizeof(wDomain)); |
| if (!ptr) return NULL; |
| ustr = (UNICODE_STRING*)(ptr + ofs); |
| ustr->MaximumLength = sizeof(wDomain); |
| ustr->Buffer = (WCHAR*)(ptr + sz); |
| ustr->Length = sizeof(wDomain) - sizeof(WCHAR); |
| memcpy(ustr->Buffer, wDomain, sizeof(wDomain)); |
| } |
| return ptr; |
| } |
| |
| /****************************************************************************** |
| * LsaAddAccountRights [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaAddAccountRights( |
| LSA_HANDLE policy, |
| PSID sid, |
| PLSA_UNICODE_STRING rights, |
| ULONG count) |
| { |
| FIXME("(%p,%p,%p,0x%08x) stub\n", policy, sid, rights, count); |
| return STATUS_OBJECT_NAME_NOT_FOUND; |
| } |
| |
| /****************************************************************************** |
| * LsaClose [ADVAPI32.@] |
| * |
| * Closes a handle to a Policy or TrustedDomain. |
| * |
| * PARAMS |
| * ObjectHandle [I] Handle to a Policy or TrustedDomain. |
| * |
| * RETURNS |
| * Success: STATUS_SUCCESS. |
| * Failure: NTSTATUS code. |
| */ |
| NTSTATUS WINAPI LsaClose(IN LSA_HANDLE ObjectHandle) |
| { |
| FIXME("(%p) stub\n", ObjectHandle); |
| return STATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * LsaCreateTrustedDomainEx [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaCreateTrustedDomainEx( |
| LSA_HANDLE policy, |
| PTRUSTED_DOMAIN_INFORMATION_EX domain_info, |
| PTRUSTED_DOMAIN_AUTH_INFORMATION auth_info, |
| ACCESS_MASK access, |
| PLSA_HANDLE domain) |
| { |
| FIXME("(%p,%p,%p,0x%08x,%p) stub\n", policy, domain_info, auth_info, |
| access, domain); |
| return STATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * LsaDeleteTrustedDomain [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaDeleteTrustedDomain(LSA_HANDLE policy, PSID sid) |
| { |
| FIXME("(%p,%p) stub\n", policy, sid); |
| return STATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * LsaEnumerateAccountRights [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaEnumerateAccountRights( |
| LSA_HANDLE policy, |
| PSID sid, |
| PLSA_UNICODE_STRING *rights, |
| PULONG count) |
| { |
| FIXME("(%p,%p,%p,%p) stub\n", policy, sid, rights, count); |
| *rights = 0; |
| *count = 0; |
| return STATUS_OBJECT_NAME_NOT_FOUND; |
| } |
| |
| /****************************************************************************** |
| * LsaEnumerateAccountsWithUserRight [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaEnumerateAccountsWithUserRight( |
| LSA_HANDLE policy, |
| PLSA_UNICODE_STRING rights, |
| PVOID *buffer, |
| PULONG count) |
| { |
| FIXME("(%p,%p,%p,%p) stub\n", policy, rights, buffer, count); |
| return STATUS_NO_MORE_ENTRIES; |
| } |
| |
| /****************************************************************************** |
| * LsaEnumerateTrustedDomains [ADVAPI32.@] |
| * |
| * Returns the names and SIDs of trusted domains. |
| * |
| * PARAMS |
| * PolicyHandle [I] Handle to a Policy object. |
| * EnumerationContext [I] Pointer to an enumeration handle. |
| * Buffer [O] Contains the names and SIDs of trusted domains. |
| * PreferredMaximumLength[I] Preferred maximum size in bytes of Buffer. |
| * CountReturned [O] Number of elements in Buffer. |
| * |
| * RETURNS |
| * Success: STATUS_SUCCESS, |
| * STATUS_MORE_ENTRIES, |
| * STATUS_NO_MORE_ENTRIES |
| * Failure: NTSTATUS code. |
| * |
| * NOTES |
| * LsaEnumerateTrustedDomains can be called multiple times to enumerate |
| * all trusted domains. |
| */ |
| NTSTATUS WINAPI LsaEnumerateTrustedDomains( |
| IN LSA_HANDLE PolicyHandle, |
| IN PLSA_ENUMERATION_HANDLE EnumerationContext, |
| OUT PVOID* Buffer, |
| IN ULONG PreferredMaximumLength, |
| OUT PULONG CountReturned) |
| { |
| FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext, |
| Buffer, PreferredMaximumLength, CountReturned); |
| |
| if (CountReturned) *CountReturned = 0; |
| return STATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * LsaEnumerateTrustedDomainsEx [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaEnumerateTrustedDomainsEx( |
| LSA_HANDLE policy, |
| PLSA_ENUMERATION_HANDLE context, |
| PVOID *buffer, |
| ULONG length, |
| PULONG count) |
| { |
| FIXME("(%p,%p,%p,0x%08x,%p) stub\n", policy, context, buffer, length, count); |
| |
| if (count) *count = 0; |
| return STATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * LsaFreeMemory [ADVAPI32.@] |
| * |
| * Frees memory allocated by a LSA function. |
| * |
| * PARAMS |
| * Buffer [I] Memory buffer to free. |
| * |
| * RETURNS |
| * Success: STATUS_SUCCESS. |
| * Failure: NTSTATUS code. |
| */ |
| NTSTATUS WINAPI LsaFreeMemory(IN PVOID Buffer) |
| { |
| TRACE("(%p)\n", Buffer); |
| |
| HeapFree(GetProcessHeap(), 0, Buffer); |
| return STATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * LsaLookupNames [ADVAPI32.@] |
| * |
| * Returns the SIDs of an array of user, group, or local group names. |
| * |
| * PARAMS |
| * PolicyHandle [I] Handle to a Policy object. |
| * Count [I] Number of names in Names. |
| * Names [I] Array of names to lookup. |
| * ReferencedDomains [O] Array of domains where the names were found. |
| * Sids [O] Array of SIDs corresponding to Names. |
| * |
| * RETURNS |
| * Success: STATUS_SUCCESS, |
| * STATUS_SOME_NOT_MAPPED |
| * Failure: STATUS_NONE_MAPPED or NTSTATUS code. |
| */ |
| NTSTATUS WINAPI LsaLookupNames( |
| IN LSA_HANDLE PolicyHandle, |
| IN ULONG Count, |
| IN PLSA_UNICODE_STRING Names, |
| OUT PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains, |
| OUT PLSA_TRANSLATED_SID* Sids) |
| { |
| FIXME("(%p,0x%08x,%p,%p,%p) stub\n", PolicyHandle, Count, Names, |
| ReferencedDomains, Sids); |
| |
| return STATUS_NONE_MAPPED; |
| } |
| |
| static BOOL lookup_name( LSA_UNICODE_STRING *name, SID *sid, DWORD *sid_size, WCHAR *domain, |
| DWORD *domain_size, SID_NAME_USE *use, BOOL *handled ) |
| { |
| BOOL ret; |
| |
| ret = lookup_local_wellknown_name( name, sid, sid_size, domain, domain_size, use, handled ); |
| if (!*handled) |
| ret = lookup_local_user_name( name, sid, sid_size, domain, domain_size, use, handled ); |
| |
| return ret; |
| } |
| |
| /* Adds domain info to referenced domain list. |
| Domain list is stored as plain buffer, layout is: |
| |
| LSA_REFERENCED_DOMAIN_LIST, |
| LSA_TRUST_INFORMATION array, |
| domain data array of |
| { |
| domain name data (WCHAR buffer), |
| SID data |
| } |
| |
| Parameters: |
| list [I] referenced list pointer |
| domain [I] domain name string |
| data [IO] pointer to domain data array |
| */ |
| static LONG lsa_reflist_add_domain(LSA_REFERENCED_DOMAIN_LIST *list, LSA_UNICODE_STRING *domain, char **data) |
| { |
| ULONG sid_size = 0,domain_size = 0; |
| BOOL handled = FALSE; |
| SID_NAME_USE use; |
| LONG i; |
| |
| for (i = 0; i < list->Entries; i++) |
| { |
| /* try to reuse index */ |
| if ((list->Domains[i].Name.Length == domain->Length) && |
| (!strncmpiW(list->Domains[i].Name.Buffer, domain->Buffer, (domain->Length / sizeof(WCHAR))))) |
| { |
| return i; |
| } |
| } |
| |
| /* no matching domain found, store name */ |
| list->Domains[list->Entries].Name.Length = domain->Length; |
| list->Domains[list->Entries].Name.MaximumLength = domain->MaximumLength; |
| list->Domains[list->Entries].Name.Buffer = (WCHAR*)*data; |
| memcpy(list->Domains[list->Entries].Name.Buffer, domain->Buffer, domain->MaximumLength); |
| *data += domain->MaximumLength; |
| |
| /* get and store SID data */ |
| list->Domains[list->Entries].Sid = *data; |
| lookup_name(domain, NULL, &sid_size, NULL, &domain_size, &use, &handled); |
| domain_size = 0; |
| lookup_name(domain, list->Domains[list->Entries].Sid, &sid_size, NULL, &domain_size, &use, &handled); |
| *data += sid_size; |
| |
| return list->Entries++; |
| } |
| |
| /****************************************************************************** |
| * LsaLookupNames2 [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaLookupNames2( LSA_HANDLE policy, ULONG flags, ULONG count, |
| PLSA_UNICODE_STRING names, PLSA_REFERENCED_DOMAIN_LIST *domains, |
| PLSA_TRANSLATED_SID2 *sids ) |
| { |
| ULONG i, sid_size_total = 0, domain_size_max = 0, size, domainname_size_total = 0; |
| ULONG sid_size, domain_size, mapped; |
| LSA_UNICODE_STRING domain; |
| BOOL handled = FALSE; |
| char *domain_data; |
| SID_NAME_USE use; |
| SID *sid; |
| |
| TRACE("(%p,0x%08x,0x%08x,%p,%p,%p)\n", policy, flags, count, names, domains, sids); |
| |
| mapped = 0; |
| for (i = 0; i < count; i++) |
| { |
| handled = FALSE; |
| sid_size = domain_size = 0; |
| lookup_name( &names[i], NULL, &sid_size, NULL, &domain_size, &use, &handled ); |
| if (handled) |
| { |
| sid_size_total += sid_size; |
| domainname_size_total += domain_size; |
| if (domain_size) |
| { |
| if (domain_size > domain_size_max) |
| domain_size_max = domain_size; |
| } |
| mapped++; |
| } |
| } |
| TRACE("mapped %u out of %u\n", mapped, count); |
| |
| size = sizeof(LSA_TRANSLATED_SID2) * count + sid_size_total; |
| if (!(*sids = heap_alloc(size))) return STATUS_NO_MEMORY; |
| |
| sid = (SID *)(*sids + count); |
| |
| /* use maximum domain count */ |
| if (!(*domains = heap_alloc(sizeof(LSA_REFERENCED_DOMAIN_LIST) + sizeof(LSA_TRUST_INFORMATION)*count + |
| sid_size_total + domainname_size_total*sizeof(WCHAR)))) |
| { |
| heap_free(*sids); |
| return STATUS_NO_MEMORY; |
| } |
| (*domains)->Entries = 0; |
| (*domains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*domains + sizeof(LSA_REFERENCED_DOMAIN_LIST)); |
| domain_data = (char*)(*domains)->Domains + sizeof(LSA_TRUST_INFORMATION)*count; |
| |
| domain.Buffer = heap_alloc(domain_size_max*sizeof(WCHAR)); |
| for (i = 0; i < count; i++) |
| { |
| domain.Length = domain_size_max*sizeof(WCHAR); |
| domain.MaximumLength = domain_size_max*sizeof(WCHAR); |
| |
| (*sids)[i].Use = SidTypeUnknown; |
| (*sids)[i].DomainIndex = -1; |
| (*sids)[i].Flags = 0; |
| |
| handled = FALSE; |
| sid_size = sid_size_total; |
| domain_size = domain_size_max; |
| lookup_name( &names[i], sid, &sid_size, domain.Buffer, &domain_size, &use, &handled ); |
| if (handled) |
| { |
| (*sids)[i].Sid = sid; |
| (*sids)[i].Use = use; |
| |
| sid = (SID *)((char *)sid + sid_size); |
| sid_size_total -= sid_size; |
| if (domain_size) |
| { |
| domain.Length = domain_size * sizeof(WCHAR); |
| domain.MaximumLength = (domain_size + 1) * sizeof(WCHAR); |
| (*sids)[i].DomainIndex = lsa_reflist_add_domain(*domains, &domain, &domain_data); |
| } |
| } |
| } |
| heap_free(domain.Buffer); |
| |
| if (mapped == count) return STATUS_SUCCESS; |
| if (mapped > 0 && mapped < count) return STATUS_SOME_NOT_MAPPED; |
| return STATUS_NONE_MAPPED; |
| } |
| |
| /****************************************************************************** |
| * LsaLookupSids [ADVAPI32.@] |
| * |
| * Looks up the names that correspond to an array of SIDs. |
| * |
| * PARAMS |
| * PolicyHandle [I] Handle to a Policy object. |
| * Count [I] Number of SIDs in the Sids array. |
| * Sids [I] Array of SIDs to lookup. |
| * ReferencedDomains [O] Array of domains where the sids were found. |
| * Names [O] Array of names corresponding to Sids. |
| * |
| * RETURNS |
| * Success: STATUS_SUCCESS, |
| * STATUS_SOME_NOT_MAPPED |
| * Failure: STATUS_NONE_MAPPED or NTSTATUS code. |
| */ |
| NTSTATUS WINAPI LsaLookupSids( |
| LSA_HANDLE PolicyHandle, |
| ULONG Count, |
| PSID *Sids, |
| LSA_REFERENCED_DOMAIN_LIST **ReferencedDomains, |
| LSA_TRANSLATED_NAME **Names) |
| { |
| ULONG i, mapped, name_fullsize, domain_fullsize; |
| ULONG name_size, domain_size; |
| LSA_UNICODE_STRING domain; |
| WCHAR *name_buffer; |
| char *domain_data; |
| SID_NAME_USE use; |
| |
| TRACE("(%p, %u, %p, %p, %p)\n", PolicyHandle, Count, Sids, ReferencedDomains, Names); |
| |
| /* this length does not include actual string length yet */ |
| name_fullsize = sizeof(LSA_TRANSLATED_NAME) * Count; |
| if (!(*Names = heap_alloc(name_fullsize))) return STATUS_NO_MEMORY; |
| /* maximum count of stored domain infos is Count, allocate it like that cause really needed |
| count could only be computed after sid data is retrieved */ |
| domain_fullsize = sizeof(LSA_REFERENCED_DOMAIN_LIST) + sizeof(LSA_TRUST_INFORMATION)*Count; |
| if (!(*ReferencedDomains = heap_alloc(domain_fullsize))) |
| { |
| heap_free(*Names); |
| return STATUS_NO_MEMORY; |
| } |
| (*ReferencedDomains)->Entries = 0; |
| (*ReferencedDomains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*ReferencedDomains + sizeof(LSA_REFERENCED_DOMAIN_LIST)); |
| |
| /* Get full names data length and full length needed to store domain name and SID */ |
| for (i = 0; i < Count; i++) |
| { |
| (*Names)[i].Use = SidTypeUnknown; |
| (*Names)[i].DomainIndex = -1; |
| (*Names)[i].Name.Buffer = NULL; |
| |
| memset(&(*ReferencedDomains)->Domains[i], 0, sizeof(LSA_TRUST_INFORMATION)); |
| |
| name_size = domain_size = 0; |
| if (!LookupAccountSidW(NULL, Sids[i], NULL, &name_size, NULL, &domain_size, &use) && |
| GetLastError() == ERROR_INSUFFICIENT_BUFFER) |
| { |
| if (name_size) |
| { |
| (*Names)[i].Name.Length = (name_size - 1) * sizeof(WCHAR); |
| (*Names)[i].Name.MaximumLength = name_size * sizeof(WCHAR); |
| name_fullsize += (*Names)[i].Name.MaximumLength; |
| } |
| else |
| { |
| (*Names)[i].Name.Length = 0; |
| (*Names)[i].Name.MaximumLength = 0; |
| } |
| |
| /* This potentially allocates more than needed, cause different names will reuse same domain index. |
| Also it's not possible to store domain name length right here for the same reason. */ |
| if (domain_size) |
| { |
| ULONG sid_size = 0; |
| BOOL handled = FALSE; |
| WCHAR *name; |
| |
| domain_fullsize += domain_size * sizeof(WCHAR); |
| |
| /* get domain SID size too */ |
| name = heap_alloc(domain_size * sizeof(WCHAR)); |
| *name = 0; |
| LookupAccountSidW(NULL, Sids[i], NULL, &name_size, name, &domain_size, &use); |
| |
| domain.Buffer = name; |
| domain.Length = domain_size * sizeof(WCHAR); |
| domain.MaximumLength = domain_size * sizeof(WCHAR); |
| |
| lookup_name(&domain, NULL, &sid_size, NULL, &domain_size, &use, &handled); |
| domain_fullsize += sid_size; |
| |
| heap_free(name); |
| } |
| } |
| } |
| |
| /* now we have full length needed for both */ |
| *Names = heap_realloc(*Names, name_fullsize); |
| name_buffer = (WCHAR*)((char*)*Names + sizeof(LSA_TRANSLATED_NAME)*Count); |
| |
| *ReferencedDomains = heap_realloc(*ReferencedDomains, domain_fullsize); |
| /* fix pointer after reallocation */ |
| (*ReferencedDomains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*ReferencedDomains + sizeof(LSA_REFERENCED_DOMAIN_LIST)); |
| domain_data = (char*)(*ReferencedDomains)->Domains + sizeof(LSA_TRUST_INFORMATION)*Count; |
| |
| mapped = 0; |
| for (i = 0; i < Count; i++) |
| { |
| name_size = domain_size = 0; |
| |
| if (!LookupAccountSidW(NULL, Sids[i], NULL, &name_size, NULL, &domain_size, &use) && |
| GetLastError() == ERROR_INSUFFICIENT_BUFFER) |
| { |
| mapped++; |
| |
| if (domain_size) |
| { |
| domain.Length = (domain_size - 1) * sizeof(WCHAR); |
| domain.MaximumLength = domain_size * sizeof(WCHAR); |
| domain.Buffer = heap_alloc(domain.MaximumLength); |
| } |
| |
| (*Names)[i].Name.Buffer = name_buffer; |
| LookupAccountSidW(NULL, Sids[i], (*Names)[i].Name.Buffer, &name_size, domain.Buffer, &domain_size, &use); |
| (*Names)[i].Use = use; |
| |
| if (domain_size) |
| { |
| (*Names)[i].DomainIndex = lsa_reflist_add_domain(*ReferencedDomains, &domain, &domain_data); |
| heap_free(domain.Buffer); |
| } |
| } |
| |
| name_buffer += name_size; |
| } |
| TRACE("mapped %u out of %u\n", mapped, Count); |
| |
| if (mapped == Count) return STATUS_SUCCESS; |
| if (mapped) return STATUS_SOME_NOT_MAPPED; |
| return STATUS_NONE_MAPPED; |
| } |
| |
| /****************************************************************************** |
| * LsaNtStatusToWinError [ADVAPI32.@] |
| * |
| * Converts an LSA NTSTATUS code to a Windows error code. |
| * |
| * PARAMS |
| * Status [I] NTSTATUS code. |
| * |
| * RETURNS |
| * Success: Corresponding Windows error code. |
| * Failure: ERROR_MR_MID_NOT_FOUND. |
| */ |
| ULONG WINAPI LsaNtStatusToWinError(NTSTATUS Status) |
| { |
| return RtlNtStatusToDosError(Status); |
| } |
| |
| /****************************************************************************** |
| * LsaOpenPolicy [ADVAPI32.@] |
| * |
| * Opens a handle to the Policy object on a local or remote system. |
| * |
| * PARAMS |
| * SystemName [I] Name of the target system. |
| * ObjectAttributes [I] Connection attributes. |
| * DesiredAccess [I] Requested access rights. |
| * PolicyHandle [I/O] Handle to the Policy object. |
| * |
| * RETURNS |
| * Success: STATUS_SUCCESS. |
| * Failure: NTSTATUS code. |
| * |
| * NOTES |
| * Set SystemName to NULL to open the local Policy object. |
| */ |
| NTSTATUS WINAPI LsaOpenPolicy( |
| IN PLSA_UNICODE_STRING SystemName, |
| IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes, |
| IN ACCESS_MASK DesiredAccess, |
| IN OUT PLSA_HANDLE PolicyHandle) |
| { |
| FIXME("(%s,%p,0x%08x,%p) stub\n", |
| SystemName?debugstr_w(SystemName->Buffer):"(null)", |
| ObjectAttributes, DesiredAccess, PolicyHandle); |
| |
| ADVAPI_ForceLocalComputer(SystemName ? SystemName->Buffer : NULL, |
| STATUS_ACCESS_VIOLATION); |
| dumpLsaAttributes(ObjectAttributes); |
| |
| if(PolicyHandle) *PolicyHandle = (LSA_HANDLE)0xcafe; |
| return STATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * LsaOpenTrustedDomainByName [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaOpenTrustedDomainByName( |
| LSA_HANDLE policy, |
| PLSA_UNICODE_STRING name, |
| ACCESS_MASK access, |
| PLSA_HANDLE handle) |
| { |
| FIXME("(%p,%p,0x%08x,%p) stub\n", policy, name, access, handle); |
| return STATUS_OBJECT_NAME_NOT_FOUND; |
| } |
| |
| /****************************************************************************** |
| * LsaQueryInformationPolicy [ADVAPI32.@] |
| * |
| * Returns information about a Policy object. |
| * |
| * PARAMS |
| * PolicyHandle [I] Handle to a Policy object. |
| * InformationClass [I] Type of information to retrieve. |
| * Buffer [O] Pointer to the requested information. |
| * |
| * RETURNS |
| * Success: STATUS_SUCCESS. |
| * Failure: NTSTATUS code. |
| */ |
| NTSTATUS WINAPI LsaQueryInformationPolicy( |
| IN LSA_HANDLE PolicyHandle, |
| IN POLICY_INFORMATION_CLASS InformationClass, |
| OUT PVOID *Buffer) |
| { |
| TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer); |
| |
| if(!Buffer) return STATUS_INVALID_PARAMETER; |
| switch (InformationClass) |
| { |
| case PolicyAuditEventsInformation: /* 2 */ |
| { |
| PPOLICY_AUDIT_EVENTS_INFO p = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, |
| sizeof(POLICY_AUDIT_EVENTS_INFO)); |
| p->AuditingMode = FALSE; /* no auditing */ |
| *Buffer = p; |
| } |
| break; |
| case PolicyPrimaryDomainInformation: /* 3 */ |
| { |
| /* Only the domain name is valid for the local computer. |
| * All other fields are zero. |
| */ |
| PPOLICY_PRIMARY_DOMAIN_INFO pinfo; |
| |
| pinfo = ADVAPI_GetDomainName(sizeof(*pinfo), offsetof(POLICY_PRIMARY_DOMAIN_INFO, Name)); |
| |
| TRACE("setting domain to %s\n", debugstr_w(pinfo->Name.Buffer)); |
| |
| *Buffer = pinfo; |
| } |
| break; |
| case PolicyAccountDomainInformation: /* 5 */ |
| { |
| struct di |
| { |
| POLICY_ACCOUNT_DOMAIN_INFO info; |
| SID sid; |
| DWORD padding[3]; |
| WCHAR domain[MAX_COMPUTERNAME_LENGTH + 1]; |
| }; |
| |
| DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1; |
| struct di * xdi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*xdi)); |
| |
| xdi->info.DomainName.MaximumLength = dwSize * sizeof(WCHAR); |
| xdi->info.DomainName.Buffer = xdi->domain; |
| if (GetComputerNameW(xdi->info.DomainName.Buffer, &dwSize)) |
| xdi->info.DomainName.Length = dwSize * sizeof(WCHAR); |
| |
| TRACE("setting name to %s\n", debugstr_w(xdi->info.DomainName.Buffer)); |
| |
| xdi->info.DomainSid = &xdi->sid; |
| |
| if (!ADVAPI_GetComputerSid(&xdi->sid)) |
| { |
| HeapFree(GetProcessHeap(), 0, xdi); |
| |
| WARN("Computer SID not found\n"); |
| |
| return STATUS_UNSUCCESSFUL; |
| } |
| |
| TRACE("setting SID to %s\n", debugstr_sid(&xdi->sid)); |
| |
| *Buffer = xdi; |
| } |
| break; |
| case PolicyDnsDomainInformation: /* 12 (0xc) */ |
| { |
| /* Only the domain name is valid for the local computer. |
| * All other fields are zero. |
| */ |
| PPOLICY_DNS_DOMAIN_INFO pinfo; |
| |
| pinfo = ADVAPI_GetDomainName(sizeof(*pinfo), offsetof(POLICY_DNS_DOMAIN_INFO, Name)); |
| |
| TRACE("setting domain to %s\n", debugstr_w(pinfo->Name.Buffer)); |
| |
| *Buffer = pinfo; |
| } |
| break; |
| case PolicyAuditLogInformation: |
| case PolicyPdAccountInformation: |
| case PolicyLsaServerRoleInformation: |
| case PolicyReplicaSourceInformation: |
| case PolicyDefaultQuotaInformation: |
| case PolicyModificationInformation: |
| case PolicyAuditFullSetInformation: |
| case PolicyAuditFullQueryInformation: |
| { |
| FIXME("category %d not implemented\n", InformationClass); |
| return STATUS_UNSUCCESSFUL; |
| } |
| } |
| return STATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * LsaQueryTrustedDomainInfo [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaQueryTrustedDomainInfo( |
| LSA_HANDLE policy, |
| PSID sid, |
| TRUSTED_INFORMATION_CLASS class, |
| PVOID *buffer) |
| { |
| FIXME("(%p,%p,%d,%p) stub\n", policy, sid, class, buffer); |
| return STATUS_OBJECT_NAME_NOT_FOUND; |
| } |
| |
| /****************************************************************************** |
| * LsaQueryTrustedDomainInfoByName [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaQueryTrustedDomainInfoByName( |
| LSA_HANDLE policy, |
| PLSA_UNICODE_STRING name, |
| TRUSTED_INFORMATION_CLASS class, |
| PVOID *buffer) |
| { |
| FIXME("(%p,%p,%d,%p) stub\n", policy, name, class, buffer); |
| return STATUS_OBJECT_NAME_NOT_FOUND; |
| } |
| |
| /****************************************************************************** |
| * LsaRegisterPolicyChangeNotification [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaRegisterPolicyChangeNotification( |
| POLICY_NOTIFICATION_INFORMATION_CLASS class, |
| HANDLE event) |
| { |
| FIXME("(%d,%p) stub\n", class, event); |
| return STATUS_UNSUCCESSFUL; |
| } |
| |
| /****************************************************************************** |
| * LsaRemoveAccountRights [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaRemoveAccountRights( |
| LSA_HANDLE policy, |
| PSID sid, |
| BOOLEAN all, |
| PLSA_UNICODE_STRING rights, |
| ULONG count) |
| { |
| FIXME("(%p,%p,%d,%p,0x%08x) stub\n", policy, sid, all, rights, count); |
| return STATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * LsaRetrievePrivateData [ADVAPI32.@] |
| * |
| * Retrieves data stored by LsaStorePrivateData. |
| * |
| * PARAMS |
| * PolicyHandle [I] Handle to a Policy object. |
| * KeyName [I] Name of the key where the data is stored. |
| * PrivateData [O] Pointer to the private data. |
| * |
| * RETURNS |
| * Success: STATUS_SUCCESS. |
| * Failure: STATUS_OBJECT_NAME_NOT_FOUND or NTSTATUS code. |
| */ |
| NTSTATUS WINAPI LsaRetrievePrivateData( |
| IN LSA_HANDLE PolicyHandle, |
| IN PLSA_UNICODE_STRING KeyName, |
| OUT PLSA_UNICODE_STRING* PrivateData) |
| { |
| FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData); |
| return STATUS_OBJECT_NAME_NOT_FOUND; |
| } |
| |
| /****************************************************************************** |
| * LsaSetInformationPolicy [ADVAPI32.@] |
| * |
| * Modifies information in a Policy object. |
| * |
| * PARAMS |
| * PolicyHandle [I] Handle to a Policy object. |
| * InformationClass [I] Type of information to set. |
| * Buffer [I] Pointer to the information to set. |
| * |
| * RETURNS |
| * Success: STATUS_SUCCESS. |
| * Failure: NTSTATUS code. |
| */ |
| NTSTATUS WINAPI LsaSetInformationPolicy( |
| IN LSA_HANDLE PolicyHandle, |
| IN POLICY_INFORMATION_CLASS InformationClass, |
| IN PVOID Buffer) |
| { |
| FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer); |
| |
| return STATUS_UNSUCCESSFUL; |
| } |
| |
| /****************************************************************************** |
| * LsaSetSecret [ADVAPI32.@] |
| * |
| * Set old and new values on a secret handle |
| * |
| * PARAMS |
| * SecretHandle [I] Handle to a secret object. |
| * EncryptedCurrentValue [I] Pointer to encrypted new value, can be NULL |
| * EncryptedOldValue [I] Pointer to encrypted old value, can be NULL |
| * |
| * RETURNS |
| * Success: STATUS_SUCCESS |
| * Failure: NTSTATUS code. |
| */ |
| NTSTATUS WINAPI LsaSetSecret( |
| IN LSA_HANDLE SecretHandle, |
| IN PLSA_UNICODE_STRING EncryptedCurrentValue, |
| IN PLSA_UNICODE_STRING EncryptedOldValue) |
| { |
| FIXME("(%p,%p,%p) stub\n", SecretHandle, EncryptedCurrentValue, |
| EncryptedOldValue); |
| return STATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * LsaSetTrustedDomainInfoByName [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaSetTrustedDomainInfoByName( |
| LSA_HANDLE policy, |
| PLSA_UNICODE_STRING name, |
| TRUSTED_INFORMATION_CLASS class, |
| PVOID buffer) |
| { |
| FIXME("(%p,%p,%d,%p) stub\n", policy, name, class, buffer); |
| return STATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * LsaSetTrustedDomainInformation [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaSetTrustedDomainInformation( |
| LSA_HANDLE policy, |
| PSID sid, |
| TRUSTED_INFORMATION_CLASS class, |
| PVOID buffer) |
| { |
| FIXME("(%p,%p,%d,%p) stub\n", policy, sid, class, buffer); |
| return STATUS_SUCCESS; |
| } |
| |
| /****************************************************************************** |
| * LsaStorePrivateData [ADVAPI32.@] |
| * |
| * Stores or deletes a Policy object's data under the specified reg key. |
| * |
| * PARAMS |
| * PolicyHandle [I] Handle to a Policy object. |
| * KeyName [I] Name of the key where the data will be stored. |
| * PrivateData [O] Pointer to the private data. |
| * |
| * RETURNS |
| * Success: STATUS_SUCCESS. |
| * Failure: STATUS_OBJECT_NAME_NOT_FOUND or NTSTATUS code. |
| */ |
| NTSTATUS WINAPI LsaStorePrivateData( |
| IN LSA_HANDLE PolicyHandle, |
| IN PLSA_UNICODE_STRING KeyName, |
| IN PLSA_UNICODE_STRING PrivateData) |
| { |
| FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData); |
| return STATUS_OBJECT_NAME_NOT_FOUND; |
| } |
| |
| /****************************************************************************** |
| * LsaUnregisterPolicyChangeNotification [ADVAPI32.@] |
| * |
| */ |
| NTSTATUS WINAPI LsaUnregisterPolicyChangeNotification( |
| POLICY_NOTIFICATION_INFORMATION_CLASS class, |
| HANDLE event) |
| { |
| FIXME("(%d,%p) stub\n", class, event); |
| return STATUS_SUCCESS; |
| } |
