dlls/advapi32/lsa.c

   1 /*
   2  * Implementation of the Local Security Authority API
   3  *
   4  * Copyright 1999 Juergen Schmied
   5  * Copyright 2002 Andriy Palamarchuk
   6  * Copyright 2004 Mike McCormack
   7  * Copyright 2005 Hans Leidekker
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include <stdarg.h>
  25
  26 #include "ntstatus.h"
  27 #define WIN32_NO_STATUS
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winreg.h"
  31 #include "winternl.h"
  32 #include "sddl.h"
  33 #include "advapi32_misc.h"
  34
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
  38
  39 #define ADVAPI_ForceLocalComputer(ServerName, FailureCode) \
  40     if (!ADVAPI_IsLocalComputer(ServerName)) \
  41 { \
  42         FIXME("Action Implemented for local computer only. " \
  43               "Requested for server %s\n", debugstr_w(ServerName)); \
  44         return FailureCode; \
  45 }
  46
  47 static LPCSTR debugstr_us( const UNICODE_STRING *us )
  48 {
  49     if (!us) return "(null)";
  50     return debugstr_wn(us->Buffer, us->Length / sizeof(WCHAR));
  51 }
  52
  53 static void dumpLsaAttributes(const LSA_OBJECT_ATTRIBUTES *oa)
  54 {
  55     if (oa)
  56     {
  57         TRACE("\n\tlength=%lu, rootdir=%p, objectname=%s\n\tattr=0x%08lx, sid=%s qos=%p\n",
  58               oa->Length, oa->RootDirectory,
  59               oa->ObjectName?debugstr_w(oa->ObjectName->Buffer):"null",
  60               oa->Attributes, debugstr_sid(oa->SecurityDescriptor),
  61               oa->SecurityQualityOfService);
  62     }
  63 }
  64
  65 static void* ADVAPI_GetDomainName(unsigned sz, unsigned ofs)
  66 {
  67     HKEY key;
  68     LONG ret;
  69     BYTE* ptr = NULL;
  70     UNICODE_STRING* ustr;
  71
  72     ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"System\\CurrentControlSet\\Services\\VxD\\VNETSUP", 0, KEY_READ, &key);
  73     if (ret == ERROR_SUCCESS)
  74     {
  75         DWORD size = 0;
  76         ret = RegQueryValueExW(key, L"Workgroup", NULL, NULL, NULL, &size);
  77         if (ret == ERROR_MORE_DATA || ret == ERROR_SUCCESS)
  78         {
  79             ptr = heap_alloc_zero(sz + size);
  80             if (!ptr) return NULL;
  81             ustr = (UNICODE_STRING*)(ptr + ofs);
  82             ustr->MaximumLength = size;
  83             ustr->Buffer = (WCHAR*)(ptr + sz);
  84             ret = RegQueryValueExW(key, L"Workgroup", NULL, NULL, (LPBYTE)ustr->Buffer, &size);
  85             if (ret != ERROR_SUCCESS)
  86             {
  87                 heap_free(ptr);
  88                 ptr = NULL;
  89             }
  90             else ustr->Length = size - sizeof(WCHAR);
  91         }
  92         RegCloseKey(key);
  93     }
  94     if (!ptr)
  95     {
  96         ptr = heap_alloc_zero(sz + sizeof(L"DOMAIN"));
  97         if (!ptr) return NULL;
  98         ustr = (UNICODE_STRING*)(ptr + ofs);
  99         ustr->MaximumLength = sizeof(L"DOMAIN");
 100         ustr->Buffer = (WCHAR*)(ptr + sz);
 101         ustr->Length = sizeof(L"DOMAIN") - sizeof(WCHAR);
 102         memcpy(ustr->Buffer, L"DOMAIN", sizeof(L"DOMAIN"));
 103     }
 104     return ptr;
 105 }
 106
 107 /******************************************************************************
 108  * LsaGetUserName [ADVAPI32.@]
 109  *
 110  */
 111 NTSTATUS WINAPI LsaGetUserName(PUNICODE_STRING *user_name, PUNICODE_STRING *domain_name)
 112 {
 113     UNICODE_STRING *user;
 114     DWORD user_size;
 115
 116     user_size = 0;
 117     if (GetUserNameW(NULL, &user_size) || GetLastError() != ERROR_INSUFFICIENT_BUFFER)
 118        return STATUS_UNSUCCESSFUL;
 119
 120     user = heap_alloc(sizeof(*user) + user_size * sizeof(WCHAR));
 121     if (!user) return STATUS_NO_MEMORY;
 122
 123     user->Buffer = (WCHAR *)(user + 1);
 124     user->MaximumLength = user_size * sizeof(WCHAR);
 125     user->Length = user->MaximumLength - sizeof(WCHAR);
 126     if (!GetUserNameW(user->Buffer, &user_size))
 127     {
 128         heap_free(user);
 129         return STATUS_UNSUCCESSFUL;
 130     }
 131
 132     if (domain_name)
 133     {
 134         UNICODE_STRING *domain;
 135         WCHAR computer[MAX_COMPUTERNAME_LENGTH + 1];
 136         DWORD domain_size;
 137
 138         domain_size = ARRAY_SIZE(computer);
 139         if (!GetComputerNameW(computer, &domain_size))
 140         {
 141             heap_free(user);
 142             return STATUS_UNSUCCESSFUL;
 143         }
 144
 145         domain = heap_alloc(sizeof(*domain) + (domain_size + 1) * sizeof(WCHAR));
 146         if (!domain)
 147         {
 148             heap_free(user);
 149             return STATUS_NO_MEMORY;
 150         }
 151
 152         domain->Buffer = (WCHAR *)(domain + 1);
 153         domain->Length = domain_size * sizeof(WCHAR);
 154         domain->MaximumLength = domain->Length + sizeof(WCHAR);
 155         wcscpy(domain->Buffer, computer);
 156
 157         *domain_name = domain;
 158     }
 159
 160     *user_name = user;
 161
 162     return STATUS_SUCCESS;
 163 }
 164
 165 /******************************************************************************
 166  * LsaAddAccountRights [ADVAPI32.@]
 167  *
 168  */
 169 NTSTATUS WINAPI LsaAddAccountRights(
 170     LSA_HANDLE policy,
 171     PSID sid,
 172     PLSA_UNICODE_STRING rights,
 173     ULONG count)
 174 {
 175     FIXME("(%p,%p,%p,0x%08lx) stub\n", policy, sid, rights, count);
 176     return STATUS_SUCCESS;
 177 }
 178
 179 /******************************************************************************
 180  * LsaClose [ADVAPI32.@]
 181  *
 182  * Closes a handle to a Policy or TrustedDomain.
 183  *
 184  * PARAMS
 185  *  ObjectHandle [I] Handle to a Policy or TrustedDomain.
 186  *
 187  * RETURNS
 188  *  Success: STATUS_SUCCESS.
 189  *  Failure: NTSTATUS code.
 190  */
 191 NTSTATUS WINAPI LsaClose(IN LSA_HANDLE ObjectHandle)
 192 {
 193     WARN("(%p) stub\n", ObjectHandle);
 194     return STATUS_SUCCESS;
 195 }
 196
 197 /******************************************************************************
 198  * LsaCreateTrustedDomainEx [ADVAPI32.@]
 199  *
 200  */
 201 NTSTATUS WINAPI LsaCreateTrustedDomainEx(
 202     LSA_HANDLE policy,
 203     PTRUSTED_DOMAIN_INFORMATION_EX domain_info,
 204     PTRUSTED_DOMAIN_AUTH_INFORMATION auth_info,
 205     ACCESS_MASK access,
 206     PLSA_HANDLE domain)
 207 {
 208     FIXME("(%p,%p,%p,0x%08lx,%p) stub\n", policy, domain_info, auth_info,
 209           access, domain);
 210     return STATUS_SUCCESS;
 211 }
 212
 213 /******************************************************************************
 214  * LsaDeleteTrustedDomain [ADVAPI32.@]
 215  *
 216  */
 217 NTSTATUS WINAPI LsaDeleteTrustedDomain(LSA_HANDLE policy, PSID sid)
 218 {
 219     FIXME("(%p,%p) stub\n", policy, sid);
 220     return STATUS_SUCCESS;
 221 }
 222
 223 /******************************************************************************
 224  * LsaEnumerateAccountRights [ADVAPI32.@]
 225  *
 226  */
 227 NTSTATUS WINAPI LsaEnumerateAccountRights(
 228     LSA_HANDLE policy,
 229     PSID sid,
 230     PLSA_UNICODE_STRING *rights,
 231     PULONG count)
 232 {
 233     FIXME("(%p,%p,%p,%p) stub\n", policy, sid, rights, count);
 234     *rights = 0;
 235     *count = 0;
 236     return STATUS_OBJECT_NAME_NOT_FOUND;
 237 }
 238
 239 /******************************************************************************
 240  * LsaEnumerateAccounts [ADVAPI32.@]
 241  *
 242  */
 243 NTSTATUS WINAPI LsaEnumerateAccounts(
 244     LSA_HANDLE policy,
 245     PLSA_ENUMERATION_HANDLE context,
 246     PVOID *buffer,
 247     ULONG maxlen,
 248     PULONG count)
 249 {
 250     FIXME("(%p,%p,%p,%ld,%p) stub\n", policy, context, buffer, maxlen, count);
 251     if (count) *count = 0;
 252     return STATUS_NO_MORE_ENTRIES;
 253 }
 254
 255 /******************************************************************************
 256  * LsaEnumerateAccountsWithUserRight [ADVAPI32.@]
 257  *
 258  */
 259 NTSTATUS WINAPI LsaEnumerateAccountsWithUserRight(
 260     LSA_HANDLE policy,
 261     PLSA_UNICODE_STRING rights,
 262     PVOID *buffer,
 263     PULONG count)
 264 {
 265     FIXME("(%p,%p,%p,%p) stub\n", policy, rights, buffer, count);
 266     return STATUS_NO_MORE_ENTRIES;
 267 }
 268
 269 /******************************************************************************
 270  * LsaEnumerateTrustedDomains [ADVAPI32.@]
 271  *
 272  * Returns the names and SIDs of trusted domains.
 273  *
 274  * PARAMS
 275  *  PolicyHandle          [I] Handle to a Policy object.
 276  *  EnumerationContext    [I] Pointer to an enumeration handle.
 277  *  Buffer                [O] Contains the names and SIDs of trusted domains.
 278  *  PreferredMaximumLength[I] Preferred maximum size in bytes of Buffer.
 279  *  CountReturned         [O] Number of elements in Buffer.
 280  *
 281  * RETURNS
 282  *  Success: STATUS_SUCCESS,
 283  *           STATUS_MORE_ENTRIES,
 284  *           STATUS_NO_MORE_ENTRIES
 285  *  Failure: NTSTATUS code.
 286  *
 287  * NOTES
 288  *  LsaEnumerateTrustedDomains can be called multiple times to enumerate
 289  *  all trusted domains.
 290  */
 291 NTSTATUS WINAPI LsaEnumerateTrustedDomains(
 292     IN LSA_HANDLE PolicyHandle,
 293     IN PLSA_ENUMERATION_HANDLE EnumerationContext,
 294     OUT PVOID* Buffer,
 295     IN ULONG PreferredMaximumLength,
 296     OUT PULONG CountReturned)
 297 {
 298     FIXME("(%p,%p,%p,0x%08lx,%p) stub\n", PolicyHandle, EnumerationContext,
 299           Buffer, PreferredMaximumLength, CountReturned);
 300
 301     if (CountReturned) *CountReturned = 0;
 302     return STATUS_SUCCESS;
 303 }
 304
 305 /******************************************************************************
 306  * LsaEnumerateTrustedDomainsEx [ADVAPI32.@]
 307  *
 308  */
 309 NTSTATUS WINAPI LsaEnumerateTrustedDomainsEx(
 310     LSA_HANDLE policy,
 311     PLSA_ENUMERATION_HANDLE context,
 312     PVOID *buffer,
 313     ULONG length,
 314     PULONG count)
 315 {
 316     FIXME("(%p,%p,%p,0x%08lx,%p) stub\n", policy, context, buffer, length, count);
 317
 318     if (count) *count = 0;
 319     return STATUS_SUCCESS;
 320 }
 321
 322 /******************************************************************************
 323  * LsaFreeMemory [ADVAPI32.@]
 324  *
 325  * Frees memory allocated by a LSA function.
 326  *
 327  * PARAMS
 328  *  Buffer [I] Memory buffer to free.
 329  *
 330  * RETURNS
 331  *  Success: STATUS_SUCCESS.
 332  *  Failure: NTSTATUS code.
 333  */
 334 NTSTATUS WINAPI LsaFreeMemory(IN PVOID Buffer)
 335 {
 336     TRACE("(%p)\n", Buffer);
 337
 338     heap_free(Buffer);
 339     return STATUS_SUCCESS;
 340 }
 341
 342 /******************************************************************************
 343  * LsaLookupNames [ADVAPI32.@]
 344  *
 345  * Returns the SIDs of an array of user, group, or local group names.
 346  *
 347  * PARAMS
 348  *  PolicyHandle      [I] Handle to a Policy object.
 349  *  Count             [I] Number of names in Names.
 350  *  Names             [I] Array of names to lookup.
 351  *  ReferencedDomains [O] Array of domains where the names were found.
 352  *  Sids              [O] Array of SIDs corresponding to Names.
 353  *
 354  * RETURNS
 355  *  Success: STATUS_SUCCESS,
 356  *           STATUS_SOME_NOT_MAPPED
 357  *  Failure: STATUS_NONE_MAPPED or NTSTATUS code.
 358  */
 359 NTSTATUS WINAPI LsaLookupNames(
 360     IN LSA_HANDLE PolicyHandle,
 361     IN ULONG Count,
 362     IN PLSA_UNICODE_STRING Names,
 363     OUT PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains,
 364     OUT PLSA_TRANSLATED_SID* Sids)
 365 {
 366     FIXME("(%p,0x%08lx,%p,%p,%p) stub\n", PolicyHandle, Count, Names,
 367           ReferencedDomains, Sids);
 368
 369     return STATUS_NONE_MAPPED;
 370 }
 371
 372 static BOOL lookup_name( LSA_UNICODE_STRING *name, SID *sid, DWORD *sid_size, WCHAR *domain,
 373                          DWORD *domain_size, SID_NAME_USE *use, BOOL *handled )
 374 {
 375     BOOL ret;
 376
 377     ret = lookup_local_wellknown_name( name, sid, sid_size, domain, domain_size, use, handled );
 378     if (!*handled)
 379         ret = lookup_local_user_name( name, sid, sid_size, domain, domain_size, use, handled );
 380
 381     return ret;
 382 }
 383
 384 /* Adds domain info to referenced domain list.
 385    Domain list is stored as plain buffer, layout is:
 386
 387        LSA_REFERENCED_DOMAIN_LIST,
 388        LSA_TRUST_INFORMATION array,
 389        domain data array of
 390            {
 391                domain name data (WCHAR buffer),
 392                SID data
 393            }
 394
 395    Parameters:
 396        list   [I]  referenced list pointer
 397        domain [I]  domain name string
 398        data   [IO] pointer to domain data array
 399 */
 400 static LONG lsa_reflist_add_domain(LSA_REFERENCED_DOMAIN_LIST *list, LSA_UNICODE_STRING *domain, char **data)
 401 {
 402     ULONG sid_size = 0,domain_size = 0;
 403     BOOL handled = FALSE;
 404     SID_NAME_USE use;
 405     LONG i;
 406
 407     for (i = 0; i < list->Entries; i++)
 408     {
 409         /* try to reuse index */
 410         if ((list->Domains[i].Name.Length == domain->Length) &&
 411             (!wcsnicmp(list->Domains[i].Name.Buffer, domain->Buffer, (domain->Length / sizeof(WCHAR)))))
 412         {
 413             return i;
 414         }
 415     }
 416
 417     /* no matching domain found, store name */
 418     list->Domains[list->Entries].Name.Length = domain->Length;
 419     list->Domains[list->Entries].Name.MaximumLength = domain->MaximumLength;
 420     list->Domains[list->Entries].Name.Buffer = (WCHAR*)*data;
 421     memcpy(list->Domains[list->Entries].Name.Buffer, domain->Buffer, domain->MaximumLength);
 422     *data += domain->MaximumLength;
 423
 424     /* get and store SID data */
 425     list->Domains[list->Entries].Sid = *data;
 426     lookup_name(domain, NULL, &sid_size, NULL, &domain_size, &use, &handled);
 427     domain_size = 0;
 428     lookup_name(domain, list->Domains[list->Entries].Sid, &sid_size, NULL, &domain_size, &use, &handled);
 429     *data += sid_size;
 430
 431     return list->Entries++;
 432 }
 433
 434 /******************************************************************************
 435  * LsaLookupNames2 [ADVAPI32.@]
 436  *
 437  */
 438 NTSTATUS WINAPI LsaLookupNames2( LSA_HANDLE policy, ULONG flags, ULONG count,
 439                                  PLSA_UNICODE_STRING names, PLSA_REFERENCED_DOMAIN_LIST *domains,
 440                                  PLSA_TRANSLATED_SID2 *sids )
 441 {
 442     ULONG i, sid_size_total = 0, domain_size_max = 0, size, domainname_size_total = 0;
 443     ULONG sid_size, domain_size, mapped;
 444     LSA_UNICODE_STRING domain;
 445     BOOL handled = FALSE;
 446     char *domain_data;
 447     SID_NAME_USE use;
 448     SID *sid;
 449
 450     TRACE("(%p,0x%08lx,0x%08lx,%p,%p,%p)\n", policy, flags, count, names, domains, sids);
 451
 452     mapped = 0;
 453     for (i = 0; i < count; i++)
 454     {
 455         handled = FALSE;
 456         sid_size = domain_size = 0;
 457         lookup_name( &names[i], NULL, &sid_size, NULL, &domain_size, &use, &handled );
 458         if (handled)
 459         {
 460             sid_size_total += sid_size;
 461             domainname_size_total += domain_size;
 462             if (domain_size)
 463             {
 464                 if (domain_size > domain_size_max)
 465                     domain_size_max = domain_size;
 466             }
 467             mapped++;
 468         }
 469     }
 470     TRACE("mapped %lu out of %lu\n", mapped, count);
 471
 472     size = sizeof(LSA_TRANSLATED_SID2) * count + sid_size_total;
 473     if (!(*sids = heap_alloc(size))) return STATUS_NO_MEMORY;
 474
 475     sid = (SID *)(*sids + count);
 476
 477     /* use maximum domain count */
 478     if (!(*domains = heap_alloc(sizeof(LSA_REFERENCED_DOMAIN_LIST) + sizeof(LSA_TRUST_INFORMATION)*count +
 479                                 sid_size_total + domainname_size_total*sizeof(WCHAR))))
 480     {
 481         heap_free(*sids);
 482         return STATUS_NO_MEMORY;
 483     }
 484     (*domains)->Entries = 0;
 485     (*domains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*domains + sizeof(LSA_REFERENCED_DOMAIN_LIST));
 486     domain_data = (char*)(*domains)->Domains + sizeof(LSA_TRUST_INFORMATION)*count;
 487
 488     domain.Buffer = heap_alloc(domain_size_max*sizeof(WCHAR));
 489     for (i = 0; i < count; i++)
 490     {
 491         domain.Length = domain_size_max*sizeof(WCHAR);
 492         domain.MaximumLength = domain_size_max*sizeof(WCHAR);
 493
 494         (*sids)[i].Use = SidTypeUnknown;
 495         (*sids)[i].DomainIndex = -1;
 496         (*sids)[i].Flags = 0;
 497
 498         handled = FALSE;
 499         sid_size = sid_size_total;
 500         domain_size = domain_size_max;
 501         lookup_name( &names[i], sid, &sid_size, domain.Buffer, &domain_size, &use, &handled );
 502         if (handled)
 503         {
 504             (*sids)[i].Sid = sid;
 505             (*sids)[i].Use = use;
 506
 507             sid = (SID *)((char *)sid + sid_size);
 508             sid_size_total -= sid_size;
 509             if (domain_size)
 510             {
 511                 domain.Length = domain_size * sizeof(WCHAR);
 512                 domain.MaximumLength = (domain_size + 1) * sizeof(WCHAR);
 513                 (*sids)[i].DomainIndex = lsa_reflist_add_domain(*domains, &domain, &domain_data);
 514             }
 515         }
 516     }
 517     heap_free(domain.Buffer);
 518
 519     if (mapped == count) return STATUS_SUCCESS;
 520     if (mapped > 0 && mapped < count) return STATUS_SOME_NOT_MAPPED;
 521     return STATUS_NONE_MAPPED;
 522 }
 523
 524 /******************************************************************************
 525  * LsaLookupSids [ADVAPI32.@]
 526  *
 527  * Looks up the names that correspond to an array of SIDs.
 528  *
 529  * PARAMS
 530  *  PolicyHandle      [I] Handle to a Policy object.
 531  *  Count             [I] Number of SIDs in the Sids array.
 532  *  Sids              [I] Array of SIDs to lookup.
 533  *  ReferencedDomains [O] Array of domains where the sids were found.
 534  *  Names             [O] Array of names corresponding to Sids.
 535  *
 536  * RETURNS
 537  *  Success: STATUS_SUCCESS,
 538  *           STATUS_SOME_NOT_MAPPED
 539  *  Failure: STATUS_NONE_MAPPED or NTSTATUS code.
 540  */
 541 NTSTATUS WINAPI LsaLookupSids(
 542     LSA_HANDLE PolicyHandle,
 543     ULONG Count,
 544     PSID *Sids,
 545     LSA_REFERENCED_DOMAIN_LIST **ReferencedDomains,
 546     LSA_TRANSLATED_NAME **Names)
 547 {
 548     ULONG i, mapped, name_fullsize, domain_fullsize;
 549     ULONG name_size, domain_size;
 550     LSA_UNICODE_STRING domain;
 551     WCHAR *name_buffer;
 552     char *domain_data;
 553     SID_NAME_USE use;
 554     WCHAR *strsid;
 555
 556     TRACE("(%p, %lu, %p, %p, %p)\n", PolicyHandle, Count, Sids, ReferencedDomains, Names);
 557
 558     /* this length does not include actual string length yet */
 559     name_fullsize = sizeof(LSA_TRANSLATED_NAME) * Count;
 560     if (!(*Names = heap_alloc(name_fullsize))) return STATUS_NO_MEMORY;
 561     /* maximum count of stored domain infos is Count, allocate it like that cause really needed
 562        count could only be computed after sid data is retrieved */
 563     domain_fullsize = sizeof(LSA_REFERENCED_DOMAIN_LIST) + sizeof(LSA_TRUST_INFORMATION)*Count;
 564     if (!(*ReferencedDomains = heap_alloc(domain_fullsize)))
 565     {
 566         heap_free(*Names);
 567         return STATUS_NO_MEMORY;
 568     }
 569     (*ReferencedDomains)->Entries = 0;
 570     (*ReferencedDomains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*ReferencedDomains + sizeof(LSA_REFERENCED_DOMAIN_LIST));
 571
 572     /* Get full names data length and full length needed to store domain name and SID */
 573     for (i = 0; i < Count; i++)
 574     {
 575         (*Names)[i].Use = SidTypeUnknown;
 576         (*Names)[i].DomainIndex = -1;
 577         RtlInitUnicodeStringEx(&(*Names)[i].Name, NULL);
 578
 579         memset(&(*ReferencedDomains)->Domains[i], 0, sizeof(LSA_TRUST_INFORMATION));
 580
 581         name_size = domain_size = 0;
 582         if (!LookupAccountSidW(NULL, Sids[i], NULL, &name_size, NULL, &domain_size, &use) &&
 583             GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 584         {
 585             if (name_size)
 586             {
 587                 (*Names)[i].Name.Length = (name_size - 1) * sizeof(WCHAR);
 588                 (*Names)[i].Name.MaximumLength = name_size * sizeof(WCHAR);
 589             }
 590             else
 591             {
 592                 (*Names)[i].Name.Length = 0;
 593                 (*Names)[i].Name.MaximumLength = sizeof(WCHAR);
 594             }
 595
 596             name_fullsize += (*Names)[i].Name.MaximumLength;
 597
 598             /* This potentially allocates more than needed, cause different names will reuse same domain index.
 599                Also it's not possible to store domain name length right here for the same reason. */
 600             if (domain_size)
 601             {
 602                 ULONG sid_size = 0;
 603                 BOOL handled = FALSE;
 604                 WCHAR *name;
 605
 606                 domain_fullsize += domain_size * sizeof(WCHAR);
 607
 608                 /* get domain SID size too */
 609                 name = heap_alloc(domain_size * sizeof(WCHAR));
 610                 *name = 0;
 611                 LookupAccountSidW(NULL, Sids[i], NULL, &name_size, name, &domain_size, &use);
 612
 613                 domain.Buffer = name;
 614                 domain.Length = domain_size * sizeof(WCHAR);
 615                 domain.MaximumLength = domain_size * sizeof(WCHAR);
 616
 617                 lookup_name(&domain, NULL, &sid_size, NULL, &domain_size, &use, &handled);
 618                 domain_fullsize += sid_size;
 619
 620                 heap_free(name);
 621             }
 622             else
 623             {
 624                 /* If we don't have a domain name, use a zero-length entry rather than a null value. */
 625                 domain_fullsize += sizeof(WCHAR);
 626                 domain.Length = 0;
 627                 domain.MaximumLength = sizeof(WCHAR);
 628             }
 629         }
 630         else if (ConvertSidToStringSidW(Sids[i], &strsid))
 631         {
 632             (*Names)[i].Name.Length = lstrlenW(strsid) * sizeof(WCHAR);
 633             (*Names)[i].Name.MaximumLength = (lstrlenW(strsid) + 1) * sizeof(WCHAR);
 634             name_fullsize += (lstrlenW(strsid) + 1) * sizeof(WCHAR);
 635
 636             LocalFree(strsid);
 637         }
 638     }
 639
 640     /* now we have full length needed for both */
 641     *Names = heap_realloc(*Names, name_fullsize);
 642     name_buffer = (WCHAR*)((char*)*Names + sizeof(LSA_TRANSLATED_NAME)*Count);
 643
 644     *ReferencedDomains = heap_realloc(*ReferencedDomains, domain_fullsize);
 645     /* fix pointer after reallocation */
 646     (*ReferencedDomains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*ReferencedDomains + sizeof(LSA_REFERENCED_DOMAIN_LIST));
 647     domain_data = (char*)(*ReferencedDomains)->Domains + sizeof(LSA_TRUST_INFORMATION)*Count;
 648
 649     mapped = 0;
 650     for (i = 0; i < Count; i++)
 651     {
 652         name_size = domain_size = 0;
 653
 654         (*Names)[i].Name.Buffer = name_buffer;
 655
 656         if (!LookupAccountSidW(NULL, Sids[i], NULL, &name_size, NULL, &domain_size, &use) &&
 657             GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 658         {
 659             mapped++;
 660
 661             if (domain_size)
 662             {
 663                 domain.Length = (domain_size - 1) * sizeof(WCHAR);
 664                 domain.MaximumLength = domain_size * sizeof(WCHAR);
 665             }
 666             else
 667             {
 668                 /* Use a zero-length buffer */
 669                 domain.Length = 0;
 670                 domain.MaximumLength = sizeof(WCHAR);
 671             }
 672
 673             domain.Buffer = heap_alloc(domain.MaximumLength);
 674
 675             LookupAccountSidW(NULL, Sids[i], (*Names)[i].Name.Buffer, &name_size, domain.Buffer, &domain_size, &use);
 676             (*Names)[i].Use = use;
 677
 678             (*Names)[i].DomainIndex = lsa_reflist_add_domain(*ReferencedDomains, &domain, &domain_data);
 679             heap_free(domain.Buffer);
 680         }
 681         else if (ConvertSidToStringSidW(Sids[i], &strsid))
 682         {
 683             lstrcpyW((*Names)[i].Name.Buffer, strsid);
 684             LocalFree(strsid);
 685         }
 686
 687         name_buffer += lstrlenW(name_buffer) + 1;
 688     }
 689     TRACE("mapped %lu out of %lu\n", mapped, Count);
 690
 691     if (mapped == Count) return STATUS_SUCCESS;
 692     if (mapped) return STATUS_SOME_NOT_MAPPED;
 693     return STATUS_NONE_MAPPED;
 694 }
 695
 696 /******************************************************************************
 697  * LsaNtStatusToWinError [ADVAPI32.@]
 698  *
 699  * Converts an LSA NTSTATUS code to a Windows error code.
 700  *
 701  * PARAMS
 702  *  Status [I] NTSTATUS code.
 703  *
 704  * RETURNS
 705  *  Success: Corresponding Windows error code.
 706  *  Failure: ERROR_MR_MID_NOT_FOUND.
 707  */
 708 ULONG WINAPI LsaNtStatusToWinError(NTSTATUS Status)
 709 {
 710     return RtlNtStatusToDosError(Status);
 711 }
 712
 713 /******************************************************************************
 714  * LsaOpenPolicy [ADVAPI32.@]
 715  *
 716  * Opens a handle to the Policy object on a local or remote system.
 717  *
 718  * PARAMS
 719  *  SystemName       [I] Name of the target system.
 720  *  ObjectAttributes [I] Connection attributes.
 721  *  DesiredAccess    [I] Requested access rights.
 722  *  PolicyHandle     [I/O] Handle to the Policy object.
 723  *
 724  * RETURNS
 725  *  Success: STATUS_SUCCESS.
 726  *  Failure: NTSTATUS code.
 727  *
 728  * NOTES
 729  *  Set SystemName to NULL to open the local Policy object.
 730  */
 731 NTSTATUS WINAPI LsaOpenPolicy(
 732     IN PLSA_UNICODE_STRING SystemName,
 733     IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
 734     IN ACCESS_MASK DesiredAccess,
 735     IN OUT PLSA_HANDLE PolicyHandle)
 736 {
 737     WARN("(%s,%p,0x%08lx,%p) stub\n",
 738           SystemName?debugstr_w(SystemName->Buffer):"(null)",
 739           ObjectAttributes, DesiredAccess, PolicyHandle);
 740
 741     ADVAPI_ForceLocalComputer(SystemName ? SystemName->Buffer : NULL,
 742                               STATUS_ACCESS_VIOLATION);
 743     dumpLsaAttributes(ObjectAttributes);
 744
 745     if(PolicyHandle) *PolicyHandle = (LSA_HANDLE)0xcafe;
 746     return STATUS_SUCCESS;
 747 }
 748
 749 /******************************************************************************
 750  * LsaOpenTrustedDomainByName [ADVAPI32.@]
 751  *
 752  */
 753 NTSTATUS WINAPI LsaOpenTrustedDomainByName(
 754     LSA_HANDLE policy,
 755     PLSA_UNICODE_STRING name,
 756     ACCESS_MASK access,
 757     PLSA_HANDLE handle)
 758 {
 759     FIXME("(%p,%p,0x%08lx,%p) stub\n", policy, name, access, handle);
 760     return STATUS_OBJECT_NAME_NOT_FOUND;
 761 }
 762
 763 /******************************************************************************
 764  * LsaQueryInformationPolicy [ADVAPI32.@]
 765  *
 766  * Returns information about a Policy object.
 767  *
 768  * PARAMS
 769  *  PolicyHandle     [I] Handle to a Policy object.
 770  *  InformationClass [I] Type of information to retrieve.
 771  *  Buffer           [O] Pointer to the requested information.
 772  *
 773  * RETURNS
 774  *  Success: STATUS_SUCCESS.
 775  *  Failure: NTSTATUS code.
 776  */
 777 NTSTATUS WINAPI LsaQueryInformationPolicy(
 778     IN LSA_HANDLE PolicyHandle,
 779     IN POLICY_INFORMATION_CLASS InformationClass,
 780     OUT PVOID *Buffer)
 781 {
 782     TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 783
 784     if(!Buffer) return STATUS_INVALID_PARAMETER;
 785     switch (InformationClass)
 786     {
 787         case PolicyAuditEventsInformation: /* 2 */
 788         {
 789             PPOLICY_AUDIT_EVENTS_INFO p = heap_alloc_zero(sizeof(POLICY_AUDIT_EVENTS_INFO));
 790             p->AuditingMode = FALSE; /* no auditing */
 791             *Buffer = p;
 792         }
 793         break;
 794         case PolicyPrimaryDomainInformation: /* 3 */
 795         {
 796             /* Only the domain name is valid for the local computer.
 797              * All other fields are zero.
 798              */
 799             PPOLICY_PRIMARY_DOMAIN_INFO pinfo;
 800
 801             pinfo = ADVAPI_GetDomainName(sizeof(*pinfo), offsetof(POLICY_PRIMARY_DOMAIN_INFO, Name));
 802
 803             TRACE("setting domain to %s\n", debugstr_w(pinfo->Name.Buffer));
 804
 805             *Buffer = pinfo;
 806         }
 807         break;
 808         case PolicyAccountDomainInformation: /* 5 */
 809         {
 810             struct di
 811             {
 812                 POLICY_ACCOUNT_DOMAIN_INFO info;
 813                 SID sid;
 814                 DWORD padding[3];
 815                 WCHAR domain[MAX_COMPUTERNAME_LENGTH + 1];
 816             };
 817
 818             DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
 819             struct di * xdi = heap_alloc_zero(sizeof(*xdi));
 820
 821             xdi->info.DomainName.MaximumLength = dwSize * sizeof(WCHAR);
 822             xdi->info.DomainName.Buffer = xdi->domain;
 823             if (GetComputerNameW(xdi->info.DomainName.Buffer, &dwSize))
 824                 xdi->info.DomainName.Length = dwSize * sizeof(WCHAR);
 825
 826             TRACE("setting name to %s\n", debugstr_w(xdi->info.DomainName.Buffer));
 827
 828             xdi->info.DomainSid = &xdi->sid;
 829
 830             if (!ADVAPI_GetComputerSid(&xdi->sid))
 831             {
 832                 heap_free(xdi);
 833
 834                 WARN("Computer SID not found\n");
 835
 836                 return STATUS_UNSUCCESSFUL;
 837             }
 838
 839             TRACE("setting SID to %s\n", debugstr_sid(&xdi->sid));
 840
 841             *Buffer = xdi;
 842         }
 843         break;
 844         case  PolicyDnsDomainInformation:       /* 12 (0xc) */
 845         {
 846             struct
 847             {
 848                 POLICY_DNS_DOMAIN_INFO info;
 849                 struct
 850                 {
 851                     SID sid;
 852                     DWORD sid_subauthority[3];
 853                 } domain_sid;
 854                 WCHAR domain_name[256];
 855                 WCHAR dns_domain_name[256];
 856                 WCHAR dns_forest_name[256];
 857             } *xdi;
 858             struct
 859             {
 860                 SID sid;
 861                 DWORD sid_subauthority[3];
 862             } computer_sid;
 863             DWORD dwSize;
 864
 865             xdi = heap_alloc_zero(sizeof(*xdi));
 866             if (!xdi) return STATUS_NO_MEMORY;
 867
 868             dwSize = 256;
 869             if (GetComputerNameExW(ComputerNamePhysicalDnsDomain, xdi->domain_name, &dwSize))
 870             {
 871                 WCHAR *dot;
 872
 873                 dot = wcsrchr(xdi->domain_name, '.');
 874                 if (dot) *dot = 0;
 875                 wcsupr(xdi->domain_name);
 876                 xdi->info.Name.Buffer = xdi->domain_name;
 877                 xdi->info.Name.Length = lstrlenW(xdi->domain_name) * sizeof(WCHAR);
 878                 xdi->info.Name.MaximumLength = xdi->info.Name.Length + sizeof(WCHAR);
 879                 TRACE("setting Name to %s\n", debugstr_w(xdi->info.Name.Buffer));
 880             }
 881
 882             dwSize = 256;
 883             if (GetComputerNameExW(ComputerNameDnsDomain, xdi->dns_domain_name, &dwSize))
 884             {
 885                 xdi->info.DnsDomainName.Buffer = xdi->dns_domain_name;
 886                 xdi->info.DnsDomainName.Length = dwSize * sizeof(WCHAR);
 887                 xdi->info.DnsDomainName.MaximumLength = (dwSize + 1) * sizeof(WCHAR);
 888                 TRACE("setting DnsDomainName to %s\n", debugstr_w(xdi->info.DnsDomainName.Buffer));
 889
 890                 xdi->info.DnsForestName.Buffer = xdi->dns_domain_name;
 891                 xdi->info.DnsForestName.Length = dwSize * sizeof(WCHAR);
 892                 xdi->info.DnsForestName.MaximumLength = (dwSize + 1) * sizeof(WCHAR);
 893                 TRACE("setting DnsForestName to %s\n", debugstr_w(xdi->info.DnsForestName.Buffer));
 894             }
 895
 896             dwSize = sizeof(xdi->domain_sid);
 897             if (ADVAPI_GetComputerSid(&computer_sid.sid) && GetWindowsAccountDomainSid(&computer_sid.sid, &xdi->domain_sid.sid, &dwSize))
 898             {
 899                 xdi->info.Sid = &xdi->domain_sid.sid;
 900                 TRACE("setting SID to %s\n", debugstr_sid(&xdi->domain_sid.sid));
 901             }
 902
 903             *Buffer = xdi;
 904         }
 905         break;
 906         case  PolicyAuditLogInformation:
 907         case  PolicyPdAccountInformation:
 908         case  PolicyLsaServerRoleInformation:
 909         case  PolicyReplicaSourceInformation:
 910         case  PolicyDefaultQuotaInformation:
 911         case  PolicyModificationInformation:
 912         case  PolicyAuditFullSetInformation:
 913         case  PolicyAuditFullQueryInformation:
 914         {
 915             FIXME("category %d not implemented\n", InformationClass);
 916             return STATUS_UNSUCCESSFUL;
 917         }
 918     }
 919     return STATUS_SUCCESS;
 920 }
 921
 922 /******************************************************************************
 923  * LsaQueryTrustedDomainInfo [ADVAPI32.@]
 924  *
 925  */
 926 NTSTATUS WINAPI LsaQueryTrustedDomainInfo(
 927     LSA_HANDLE policy,
 928     PSID sid,
 929     TRUSTED_INFORMATION_CLASS class,
 930     PVOID *buffer)
 931 {
 932     FIXME("(%p,%p,%d,%p) stub\n", policy, sid, class, buffer);
 933     return STATUS_OBJECT_NAME_NOT_FOUND;
 934 }
 935
 936 /******************************************************************************
 937  * LsaQueryTrustedDomainInfoByName [ADVAPI32.@]
 938  *
 939  */
 940 NTSTATUS WINAPI LsaQueryTrustedDomainInfoByName(
 941     LSA_HANDLE policy,
 942     PLSA_UNICODE_STRING name,
 943     TRUSTED_INFORMATION_CLASS class,
 944     PVOID *buffer)
 945 {
 946     FIXME("(%p,%p,%d,%p) stub\n", policy, name, class, buffer);
 947     return STATUS_OBJECT_NAME_NOT_FOUND;
 948 }
 949
 950 /******************************************************************************
 951  * LsaRegisterPolicyChangeNotification [ADVAPI32.@]
 952  *
 953  */
 954 NTSTATUS WINAPI LsaRegisterPolicyChangeNotification(
 955     POLICY_NOTIFICATION_INFORMATION_CLASS class,
 956     HANDLE event)
 957 {
 958     FIXME("(%d,%p) stub\n", class, event);
 959     return STATUS_UNSUCCESSFUL;
 960 }
 961
 962 /******************************************************************************
 963  * LsaRemoveAccountRights [ADVAPI32.@]
 964  *
 965  */
 966 NTSTATUS WINAPI LsaRemoveAccountRights(
 967     LSA_HANDLE policy,
 968     PSID sid,
 969     BOOLEAN all,
 970     PLSA_UNICODE_STRING rights,
 971     ULONG count)
 972 {
 973     FIXME("(%p,%p,%d,%p,0x%08lx) stub\n", policy, sid, all, rights, count);
 974     return STATUS_SUCCESS;
 975 }
 976
 977 /******************************************************************************
 978  * LsaRetrievePrivateData [ADVAPI32.@]
 979  *
 980  * Retrieves data stored by LsaStorePrivateData.
 981  *
 982  * PARAMS
 983  *  PolicyHandle [I] Handle to a Policy object.
 984  *  KeyName      [I] Name of the key where the data is stored.
 985  *  PrivateData  [O] Pointer to the private data.
 986  *
 987  * RETURNS
 988  *  Success: STATUS_SUCCESS.
 989  *  Failure: STATUS_OBJECT_NAME_NOT_FOUND or NTSTATUS code.
 990  */
 991 NTSTATUS WINAPI LsaRetrievePrivateData(
 992     IN LSA_HANDLE PolicyHandle,
 993     IN PLSA_UNICODE_STRING KeyName,
 994     OUT PLSA_UNICODE_STRING* PrivateData)
 995 {
 996     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 997     return STATUS_OBJECT_NAME_NOT_FOUND;
 998 }
 999
1000 /******************************************************************************
1001  * LsaSetInformationPolicy [ADVAPI32.@]
1002  *
1003  * Modifies information in a Policy object.
1004  *
1005  * PARAMS
1006  *  PolicyHandle     [I] Handle to a Policy object.
1007  *  InformationClass [I] Type of information to set.
1008  *  Buffer           [I] Pointer to the information to set.
1009  *
1010  * RETURNS
1011  *  Success: STATUS_SUCCESS.
1012  *  Failure: NTSTATUS code.
1013  */
1014 NTSTATUS WINAPI LsaSetInformationPolicy(
1015     IN LSA_HANDLE PolicyHandle,
1016     IN POLICY_INFORMATION_CLASS InformationClass,
1017     IN PVOID Buffer)
1018 {
1019     FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
1020
1021     return STATUS_UNSUCCESSFUL;
1022 }
1023
1024 /******************************************************************************
1025  * LsaSetSecret [ADVAPI32.@]
1026  *
1027  * Set old and new values on a secret handle
1028  *
1029  * PARAMS
1030  *  SecretHandle          [I] Handle to a secret object.
1031  *  EncryptedCurrentValue [I] Pointer to encrypted new value, can be NULL
1032  *  EncryptedOldValue     [I] Pointer to encrypted old value, can be NULL
1033  *
1034  * RETURNS
1035  *  Success: STATUS_SUCCESS
1036  *  Failure: NTSTATUS code.
1037  */
1038 NTSTATUS WINAPI LsaSetSecret(
1039     IN LSA_HANDLE SecretHandle,
1040     IN PLSA_UNICODE_STRING EncryptedCurrentValue,
1041     IN PLSA_UNICODE_STRING EncryptedOldValue)
1042 {
1043     FIXME("(%p,%p,%p) stub\n", SecretHandle, EncryptedCurrentValue,
1044             EncryptedOldValue);
1045     return STATUS_SUCCESS;
1046 }
1047
1048 /******************************************************************************
1049  * LsaSetTrustedDomainInfoByName [ADVAPI32.@]
1050  *
1051  */
1052 NTSTATUS WINAPI LsaSetTrustedDomainInfoByName(
1053     LSA_HANDLE policy,
1054     PLSA_UNICODE_STRING name,
1055     TRUSTED_INFORMATION_CLASS class,
1056     PVOID buffer)
1057 {
1058     FIXME("(%p,%p,%d,%p) stub\n", policy, name, class, buffer);
1059     return STATUS_SUCCESS;
1060 }
1061
1062 /******************************************************************************
1063  * LsaSetTrustedDomainInformation [ADVAPI32.@]
1064  *
1065  */
1066 NTSTATUS WINAPI LsaSetTrustedDomainInformation(
1067     LSA_HANDLE policy,
1068     PSID sid,
1069     TRUSTED_INFORMATION_CLASS class,
1070     PVOID buffer)
1071 {
1072     FIXME("(%p,%p,%d,%p) stub\n", policy, sid, class, buffer);
1073     return STATUS_SUCCESS;
1074 }
1075
1076 /******************************************************************************
1077  * LsaStorePrivateData [ADVAPI32.@]
1078  *
1079  * Stores or deletes a Policy object's data under the specified reg key.
1080  *
1081  * PARAMS
1082  *  PolicyHandle [I] Handle to a Policy object.
1083  *  KeyName      [I] Name of the key where the data will be stored.
1084  *  PrivateData  [O] Pointer to the private data.
1085  *
1086  * RETURNS
1087  *  Success: STATUS_SUCCESS.
1088  *  Failure: STATUS_OBJECT_NAME_NOT_FOUND or NTSTATUS code.
1089  */
1090 NTSTATUS WINAPI LsaStorePrivateData(
1091     IN LSA_HANDLE PolicyHandle,
1092     IN PLSA_UNICODE_STRING KeyName,
1093     IN PLSA_UNICODE_STRING PrivateData)
1094 {
1095     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
1096     return STATUS_OBJECT_NAME_NOT_FOUND;
1097 }
1098
1099 /******************************************************************************
1100  * LsaUnregisterPolicyChangeNotification [ADVAPI32.@]
1101  *
1102  */
1103 NTSTATUS WINAPI LsaUnregisterPolicyChangeNotification(
1104     POLICY_NOTIFICATION_INFORMATION_CLASS class,
1105     HANDLE event)
1106 {
1107     FIXME("(%d,%p) stub\n", class, event);
1108     return STATUS_SUCCESS;
1109 }
1110
1111 /******************************************************************************
1112  * LsaLookupPrivilegeName [ADVAPI32.@]
1113  *
1114  */
1115 NTSTATUS WINAPI LsaLookupPrivilegeName(LSA_HANDLE handle, LUID *luid, LSA_UNICODE_STRING **name)
1116 {
1117     const WCHAR *privnameW;
1118     DWORD length;
1119     WCHAR *strW;
1120
1121     TRACE("(%p,%p,%p)\n", handle, luid, name);
1122
1123     if (!luid || !handle)
1124         return STATUS_INVALID_PARAMETER;
1125
1126     *name = NULL;
1127
1128     if (!(privnameW = get_wellknown_privilege_name(luid)))
1129         return STATUS_NO_SUCH_PRIVILEGE;
1130
1131     length = lstrlenW(privnameW);
1132     *name = heap_alloc(sizeof(**name) + (length + 1) * sizeof(WCHAR));
1133     if (!*name)
1134         return STATUS_NO_MEMORY;
1135
1136     strW = (WCHAR *)(*name + 1);
1137     memcpy(strW, privnameW, length * sizeof(WCHAR));
1138     strW[length] = 0;
1139     RtlInitUnicodeString(*name, strW);
1140
1141     return STATUS_SUCCESS;
1142 }
1143
1144 /******************************************************************************
1145  * LsaLookupPrivilegeDisplayName [ADVAPI32.@]
1146  *
1147  */
1148 NTSTATUS WINAPI LsaLookupPrivilegeDisplayName(LSA_HANDLE handle, LSA_UNICODE_STRING *name,
1149     LSA_UNICODE_STRING **display_name, SHORT *language)
1150 {
1151     FIXME("(%p, %s, %p, %p)\n", handle, debugstr_us(name), display_name, language);
1152
1153     return STATUS_NO_SUCH_PRIVILEGE;
1154 }
1155
1156 /******************************************************************************
1157  * AuditQuerySystemPolicy [ADVAPI32.@]
1158  *
1159  */
1160 BOOLEAN WINAPI AuditQuerySystemPolicy(const GUID* guids, ULONG count, AUDIT_POLICY_INFORMATION** policy)
1161 {
1162
1163     FIXME("(%p, %ld, %p)\n", guids, count, policy);
1164     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1165     return FALSE;
1166 }