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 "advapi32_misc.h"
  33
  34 #include "wine/debug.h"
  35 #include "wine/unicode.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=%u, rootdir=%p, objectname=%s\n\tattr=0x%08x, 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     static const WCHAR wVNETSUP[] = {
  73         'S','y','s','t','e','m','\\',
  74         'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
  75         'S','e','r','v','i','c','e','s','\\',
  76         'V','x','D','\\','V','N','E','T','S','U','P','\0'};
  77
  78     ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, wVNETSUP, 0, KEY_READ, &key);
  79     if (ret == ERROR_SUCCESS)
  80     {
  81         DWORD size = 0;
  82         static const WCHAR wg[] = { 'W','o','r','k','g','r','o','u','p',0 };
  83
  84         ret = RegQueryValueExW(key, wg, NULL, NULL, NULL, &size);
  85         if (ret == ERROR_MORE_DATA || ret == ERROR_SUCCESS)
  86         {
  87             ptr = heap_alloc_zero(sz + size);
  88             if (!ptr) return NULL;
  89             ustr = (UNICODE_STRING*)(ptr + ofs);
  90             ustr->MaximumLength = size;
  91             ustr->Buffer = (WCHAR*)(ptr + sz);
  92             ret = RegQueryValueExW(key, wg, NULL, NULL, (LPBYTE)ustr->Buffer, &size);
  93             if (ret != ERROR_SUCCESS)
  94             {
  95                 heap_free(ptr);
  96                 ptr = NULL;
  97             }
  98             else ustr->Length = size - sizeof(WCHAR);
  99         }
 100         RegCloseKey(key);
 101     }
 102     if (!ptr)
 103     {
 104         static const WCHAR wDomain[] = {'D','O','M','A','I','N','\0'};
 105         ptr = heap_alloc_zero(sz + sizeof(wDomain));
 106         if (!ptr) return NULL;
 107         ustr = (UNICODE_STRING*)(ptr + ofs);
 108         ustr->MaximumLength = sizeof(wDomain);
 109         ustr->Buffer = (WCHAR*)(ptr + sz);
 110         ustr->Length = sizeof(wDomain) - sizeof(WCHAR);
 111         memcpy(ustr->Buffer, wDomain, sizeof(wDomain));
 112     }
 113     return ptr;
 114 }
 115
 116 /******************************************************************************
 117  * LsaAddAccountRights [ADVAPI32.@]
 118  *
 119  */
 120 NTSTATUS WINAPI LsaAddAccountRights(
 121     LSA_HANDLE policy,
 122     PSID sid,
 123     PLSA_UNICODE_STRING rights,
 124     ULONG count)
 125 {
 126     FIXME("(%p,%p,%p,0x%08x) stub\n", policy, sid, rights, count);
 127     return STATUS_SUCCESS;
 128 }
 129
 130 /******************************************************************************
 131  * LsaClose [ADVAPI32.@]
 132  *
 133  * Closes a handle to a Policy or TrustedDomain.
 134  *
 135  * PARAMS
 136  *  ObjectHandle [I] Handle to a Policy or TrustedDomain.
 137  *
 138  * RETURNS
 139  *  Success: STATUS_SUCCESS.
 140  *  Failure: NTSTATUS code.
 141  */
 142 NTSTATUS WINAPI LsaClose(IN LSA_HANDLE ObjectHandle)
 143 {
 144     FIXME("(%p) stub\n", ObjectHandle);
 145     return STATUS_SUCCESS;
 146 }
 147
 148 /******************************************************************************
 149  * LsaCreateTrustedDomainEx [ADVAPI32.@]
 150  *
 151  */
 152 NTSTATUS WINAPI LsaCreateTrustedDomainEx(
 153     LSA_HANDLE policy,
 154     PTRUSTED_DOMAIN_INFORMATION_EX domain_info,
 155     PTRUSTED_DOMAIN_AUTH_INFORMATION auth_info,
 156     ACCESS_MASK access,
 157     PLSA_HANDLE domain)
 158 {
 159     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", policy, domain_info, auth_info,
 160           access, domain);
 161     return STATUS_SUCCESS;
 162 }
 163
 164 /******************************************************************************
 165  * LsaDeleteTrustedDomain [ADVAPI32.@]
 166  *
 167  */
 168 NTSTATUS WINAPI LsaDeleteTrustedDomain(LSA_HANDLE policy, PSID sid)
 169 {
 170     FIXME("(%p,%p) stub\n", policy, sid);
 171     return STATUS_SUCCESS;
 172 }
 173
 174 /******************************************************************************
 175  * LsaEnumerateAccountRights [ADVAPI32.@]
 176  *
 177  */
 178 NTSTATUS WINAPI LsaEnumerateAccountRights(
 179     LSA_HANDLE policy,
 180     PSID sid,
 181     PLSA_UNICODE_STRING *rights,
 182     PULONG count)
 183 {
 184     FIXME("(%p,%p,%p,%p) stub\n", policy, sid, rights, count);
 185     *rights = 0;
 186     *count = 0;
 187     return STATUS_OBJECT_NAME_NOT_FOUND;
 188 }
 189
 190 /******************************************************************************
 191  * LsaEnumerateAccountsWithUserRight [ADVAPI32.@]
 192  *
 193  */
 194 NTSTATUS WINAPI LsaEnumerateAccountsWithUserRight(
 195     LSA_HANDLE policy,
 196     PLSA_UNICODE_STRING rights,
 197     PVOID *buffer,
 198     PULONG count)
 199 {
 200     FIXME("(%p,%p,%p,%p) stub\n", policy, rights, buffer, count);
 201     return STATUS_NO_MORE_ENTRIES;
 202 }
 203
 204 /******************************************************************************
 205  * LsaEnumerateTrustedDomains [ADVAPI32.@]
 206  *
 207  * Returns the names and SIDs of trusted domains.
 208  *
 209  * PARAMS
 210  *  PolicyHandle          [I] Handle to a Policy object.
 211  *  EnumerationContext    [I] Pointer to an enumeration handle.
 212  *  Buffer                [O] Contains the names and SIDs of trusted domains.
 213  *  PreferredMaximumLength[I] Preferred maximum size in bytes of Buffer.
 214  *  CountReturned         [O] Number of elements in Buffer.
 215  *
 216  * RETURNS
 217  *  Success: STATUS_SUCCESS,
 218  *           STATUS_MORE_ENTRIES,
 219  *           STATUS_NO_MORE_ENTRIES
 220  *  Failure: NTSTATUS code.
 221  *
 222  * NOTES
 223  *  LsaEnumerateTrustedDomains can be called multiple times to enumerate
 224  *  all trusted domains.
 225  */
 226 NTSTATUS WINAPI LsaEnumerateTrustedDomains(
 227     IN LSA_HANDLE PolicyHandle,
 228     IN PLSA_ENUMERATION_HANDLE EnumerationContext,
 229     OUT PVOID* Buffer,
 230     IN ULONG PreferredMaximumLength,
 231     OUT PULONG CountReturned)
 232 {
 233     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext,
 234           Buffer, PreferredMaximumLength, CountReturned);
 235
 236     if (CountReturned) *CountReturned = 0;
 237     return STATUS_SUCCESS;
 238 }
 239
 240 /******************************************************************************
 241  * LsaEnumerateTrustedDomainsEx [ADVAPI32.@]
 242  *
 243  */
 244 NTSTATUS WINAPI LsaEnumerateTrustedDomainsEx(
 245     LSA_HANDLE policy,
 246     PLSA_ENUMERATION_HANDLE context,
 247     PVOID *buffer,
 248     ULONG length,
 249     PULONG count)
 250 {
 251     FIXME("(%p,%p,%p,0x%08x,%p) stub\n", policy, context, buffer, length, count);
 252
 253     if (count) *count = 0;
 254     return STATUS_SUCCESS;
 255 }
 256
 257 /******************************************************************************
 258  * LsaFreeMemory [ADVAPI32.@]
 259  *
 260  * Frees memory allocated by a LSA function.
 261  *
 262  * PARAMS
 263  *  Buffer [I] Memory buffer to free.
 264  *
 265  * RETURNS
 266  *  Success: STATUS_SUCCESS.
 267  *  Failure: NTSTATUS code.
 268  */
 269 NTSTATUS WINAPI LsaFreeMemory(IN PVOID Buffer)
 270 {
 271     TRACE("(%p)\n", Buffer);
 272
 273     heap_free(Buffer);
 274     return STATUS_SUCCESS;
 275 }
 276
 277 /******************************************************************************
 278  * LsaLookupNames [ADVAPI32.@]
 279  *
 280  * Returns the SIDs of an array of user, group, or local group names.
 281  *
 282  * PARAMS
 283  *  PolicyHandle      [I] Handle to a Policy object.
 284  *  Count             [I] Number of names in Names.
 285  *  Names             [I] Array of names to lookup.
 286  *  ReferencedDomains [O] Array of domains where the names were found.
 287  *  Sids              [O] Array of SIDs corresponding to Names.
 288  *
 289  * RETURNS
 290  *  Success: STATUS_SUCCESS,
 291  *           STATUS_SOME_NOT_MAPPED
 292  *  Failure: STATUS_NONE_MAPPED or NTSTATUS code.
 293  */
 294 NTSTATUS WINAPI LsaLookupNames(
 295     IN LSA_HANDLE PolicyHandle,
 296     IN ULONG Count,
 297     IN PLSA_UNICODE_STRING Names,
 298     OUT PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains,
 299     OUT PLSA_TRANSLATED_SID* Sids)
 300 {
 301     FIXME("(%p,0x%08x,%p,%p,%p) stub\n", PolicyHandle, Count, Names,
 302           ReferencedDomains, Sids);
 303
 304     return STATUS_NONE_MAPPED;
 305 }
 306
 307 static BOOL lookup_name( LSA_UNICODE_STRING *name, SID *sid, DWORD *sid_size, WCHAR *domain,
 308                          DWORD *domain_size, SID_NAME_USE *use, BOOL *handled )
 309 {
 310     BOOL ret;
 311
 312     ret = lookup_local_wellknown_name( name, sid, sid_size, domain, domain_size, use, handled );
 313     if (!*handled)
 314         ret = lookup_local_user_name( name, sid, sid_size, domain, domain_size, use, handled );
 315
 316     return ret;
 317 }
 318
 319 /* Adds domain info to referenced domain list.
 320    Domain list is stored as plain buffer, layout is:
 321
 322        LSA_REFERENCED_DOMAIN_LIST,
 323        LSA_TRUST_INFORMATION array,
 324        domain data array of
 325            {
 326                domain name data (WCHAR buffer),
 327                SID data
 328            }
 329
 330    Parameters:
 331        list   [I]  referenced list pointer
 332        domain [I]  domain name string
 333        data   [IO] pointer to domain data array
 334 */
 335 static LONG lsa_reflist_add_domain(LSA_REFERENCED_DOMAIN_LIST *list, LSA_UNICODE_STRING *domain, char **data)
 336 {
 337     ULONG sid_size = 0,domain_size = 0;
 338     BOOL handled = FALSE;
 339     SID_NAME_USE use;
 340     LONG i;
 341
 342     for (i = 0; i < list->Entries; i++)
 343     {
 344         /* try to reuse index */
 345         if ((list->Domains[i].Name.Length == domain->Length) &&
 346             (!strncmpiW(list->Domains[i].Name.Buffer, domain->Buffer, (domain->Length / sizeof(WCHAR)))))
 347         {
 348             return i;
 349         }
 350     }
 351
 352     /* no matching domain found, store name */
 353     list->Domains[list->Entries].Name.Length = domain->Length;
 354     list->Domains[list->Entries].Name.MaximumLength = domain->MaximumLength;
 355     list->Domains[list->Entries].Name.Buffer = (WCHAR*)*data;
 356     memcpy(list->Domains[list->Entries].Name.Buffer, domain->Buffer, domain->MaximumLength);
 357     *data += domain->MaximumLength;
 358
 359     /* get and store SID data */
 360     list->Domains[list->Entries].Sid = *data;
 361     lookup_name(domain, NULL, &sid_size, NULL, &domain_size, &use, &handled);
 362     domain_size = 0;
 363     lookup_name(domain, list->Domains[list->Entries].Sid, &sid_size, NULL, &domain_size, &use, &handled);
 364     *data += sid_size;
 365
 366     return list->Entries++;
 367 }
 368
 369 /******************************************************************************
 370  * LsaLookupNames2 [ADVAPI32.@]
 371  *
 372  */
 373 NTSTATUS WINAPI LsaLookupNames2( LSA_HANDLE policy, ULONG flags, ULONG count,
 374                                  PLSA_UNICODE_STRING names, PLSA_REFERENCED_DOMAIN_LIST *domains,
 375                                  PLSA_TRANSLATED_SID2 *sids )
 376 {
 377     ULONG i, sid_size_total = 0, domain_size_max = 0, size, domainname_size_total = 0;
 378     ULONG sid_size, domain_size, mapped;
 379     LSA_UNICODE_STRING domain;
 380     BOOL handled = FALSE;
 381     char *domain_data;
 382     SID_NAME_USE use;
 383     SID *sid;
 384
 385     TRACE("(%p,0x%08x,0x%08x,%p,%p,%p)\n", policy, flags, count, names, domains, sids);
 386
 387     mapped = 0;
 388     for (i = 0; i < count; i++)
 389     {
 390         handled = FALSE;
 391         sid_size = domain_size = 0;
 392         lookup_name( &names[i], NULL, &sid_size, NULL, &domain_size, &use, &handled );
 393         if (handled)
 394         {
 395             sid_size_total += sid_size;
 396             domainname_size_total += domain_size;
 397             if (domain_size)
 398             {
 399                 if (domain_size > domain_size_max)
 400                     domain_size_max = domain_size;
 401             }
 402             mapped++;
 403         }
 404     }
 405     TRACE("mapped %u out of %u\n", mapped, count);
 406
 407     size = sizeof(LSA_TRANSLATED_SID2) * count + sid_size_total;
 408     if (!(*sids = heap_alloc(size))) return STATUS_NO_MEMORY;
 409
 410     sid = (SID *)(*sids + count);
 411
 412     /* use maximum domain count */
 413     if (!(*domains = heap_alloc(sizeof(LSA_REFERENCED_DOMAIN_LIST) + sizeof(LSA_TRUST_INFORMATION)*count +
 414                                 sid_size_total + domainname_size_total*sizeof(WCHAR))))
 415     {
 416         heap_free(*sids);
 417         return STATUS_NO_MEMORY;
 418     }
 419     (*domains)->Entries = 0;
 420     (*domains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*domains + sizeof(LSA_REFERENCED_DOMAIN_LIST));
 421     domain_data = (char*)(*domains)->Domains + sizeof(LSA_TRUST_INFORMATION)*count;
 422
 423     domain.Buffer = heap_alloc(domain_size_max*sizeof(WCHAR));
 424     for (i = 0; i < count; i++)
 425     {
 426         domain.Length = domain_size_max*sizeof(WCHAR);
 427         domain.MaximumLength = domain_size_max*sizeof(WCHAR);
 428
 429         (*sids)[i].Use = SidTypeUnknown;
 430         (*sids)[i].DomainIndex = -1;
 431         (*sids)[i].Flags = 0;
 432
 433         handled = FALSE;
 434         sid_size = sid_size_total;
 435         domain_size = domain_size_max;
 436         lookup_name( &names[i], sid, &sid_size, domain.Buffer, &domain_size, &use, &handled );
 437         if (handled)
 438         {
 439             (*sids)[i].Sid = sid;
 440             (*sids)[i].Use = use;
 441
 442             sid = (SID *)((char *)sid + sid_size);
 443             sid_size_total -= sid_size;
 444             if (domain_size)
 445             {
 446                 domain.Length = domain_size * sizeof(WCHAR);
 447                 domain.MaximumLength = (domain_size + 1) * sizeof(WCHAR);
 448                 (*sids)[i].DomainIndex = lsa_reflist_add_domain(*domains, &domain, &domain_data);
 449             }
 450         }
 451     }
 452     heap_free(domain.Buffer);
 453
 454     if (mapped == count) return STATUS_SUCCESS;
 455     if (mapped > 0 && mapped < count) return STATUS_SOME_NOT_MAPPED;
 456     return STATUS_NONE_MAPPED;
 457 }
 458
 459 /******************************************************************************
 460  * LsaLookupSids [ADVAPI32.@]
 461  *
 462  * Looks up the names that correspond to an array of SIDs.
 463  *
 464  * PARAMS
 465  *  PolicyHandle      [I] Handle to a Policy object.
 466  *  Count             [I] Number of SIDs in the Sids array.
 467  *  Sids              [I] Array of SIDs to lookup.
 468  *  ReferencedDomains [O] Array of domains where the sids were found.
 469  *  Names             [O] Array of names corresponding to Sids.
 470  *
 471  * RETURNS
 472  *  Success: STATUS_SUCCESS,
 473  *           STATUS_SOME_NOT_MAPPED
 474  *  Failure: STATUS_NONE_MAPPED or NTSTATUS code.
 475  */
 476 NTSTATUS WINAPI LsaLookupSids(
 477     LSA_HANDLE PolicyHandle,
 478     ULONG Count,
 479     PSID *Sids,
 480     LSA_REFERENCED_DOMAIN_LIST **ReferencedDomains,
 481     LSA_TRANSLATED_NAME **Names)
 482 {
 483     ULONG i, mapped, name_fullsize, domain_fullsize;
 484     ULONG name_size, domain_size;
 485     LSA_UNICODE_STRING domain;
 486     WCHAR *name_buffer;
 487     char *domain_data;
 488     SID_NAME_USE use;
 489
 490     TRACE("(%p, %u, %p, %p, %p)\n", PolicyHandle, Count, Sids, ReferencedDomains, Names);
 491
 492     /* this length does not include actual string length yet */
 493     name_fullsize = sizeof(LSA_TRANSLATED_NAME) * Count;
 494     if (!(*Names = heap_alloc(name_fullsize))) return STATUS_NO_MEMORY;
 495     /* maximum count of stored domain infos is Count, allocate it like that cause really needed
 496        count could only be computed after sid data is retrieved */
 497     domain_fullsize = sizeof(LSA_REFERENCED_DOMAIN_LIST) + sizeof(LSA_TRUST_INFORMATION)*Count;
 498     if (!(*ReferencedDomains = heap_alloc(domain_fullsize)))
 499     {
 500         heap_free(*Names);
 501         return STATUS_NO_MEMORY;
 502     }
 503     (*ReferencedDomains)->Entries = 0;
 504     (*ReferencedDomains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*ReferencedDomains + sizeof(LSA_REFERENCED_DOMAIN_LIST));
 505
 506     /* Get full names data length and full length needed to store domain name and SID */
 507     for (i = 0; i < Count; i++)
 508     {
 509         (*Names)[i].Use = SidTypeUnknown;
 510         (*Names)[i].DomainIndex = -1;
 511         (*Names)[i].Name.Buffer = NULL;
 512
 513         memset(&(*ReferencedDomains)->Domains[i], 0, sizeof(LSA_TRUST_INFORMATION));
 514
 515         name_size = domain_size = 0;
 516         if (!LookupAccountSidW(NULL, Sids[i], NULL, &name_size, NULL, &domain_size, &use) &&
 517             GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 518         {
 519             if (name_size)
 520             {
 521                 (*Names)[i].Name.Length = (name_size - 1) * sizeof(WCHAR);
 522                 (*Names)[i].Name.MaximumLength = name_size * sizeof(WCHAR);
 523             }
 524             else
 525             {
 526                 (*Names)[i].Name.Length = 0;
 527                 (*Names)[i].Name.MaximumLength = sizeof(WCHAR);
 528             }
 529
 530             name_fullsize += (*Names)[i].Name.MaximumLength;
 531
 532             /* This potentially allocates more than needed, cause different names will reuse same domain index.
 533                Also it's not possible to store domain name length right here for the same reason. */
 534             if (domain_size)
 535             {
 536                 ULONG sid_size = 0;
 537                 BOOL handled = FALSE;
 538                 WCHAR *name;
 539
 540                 domain_fullsize += domain_size * sizeof(WCHAR);
 541
 542                 /* get domain SID size too */
 543                 name = heap_alloc(domain_size * sizeof(WCHAR));
 544                 *name = 0;
 545                 LookupAccountSidW(NULL, Sids[i], NULL, &name_size, name, &domain_size, &use);
 546
 547                 domain.Buffer = name;
 548                 domain.Length = domain_size * sizeof(WCHAR);
 549                 domain.MaximumLength = domain_size * sizeof(WCHAR);
 550
 551                 lookup_name(&domain, NULL, &sid_size, NULL, &domain_size, &use, &handled);
 552                 domain_fullsize += sid_size;
 553
 554                 heap_free(name);
 555             }
 556             else
 557             {
 558                 /* If we don't have a domain name, use a zero-length entry rather than a null value. */
 559                 domain_fullsize += sizeof(WCHAR);
 560                 domain.Length = 0;
 561                 domain.MaximumLength = sizeof(WCHAR);
 562             }
 563         }
 564     }
 565
 566     /* now we have full length needed for both */
 567     *Names = heap_realloc(*Names, name_fullsize);
 568     name_buffer = (WCHAR*)((char*)*Names + sizeof(LSA_TRANSLATED_NAME)*Count);
 569
 570     *ReferencedDomains = heap_realloc(*ReferencedDomains, domain_fullsize);
 571     /* fix pointer after reallocation */
 572     (*ReferencedDomains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*ReferencedDomains + sizeof(LSA_REFERENCED_DOMAIN_LIST));
 573     domain_data = (char*)(*ReferencedDomains)->Domains + sizeof(LSA_TRUST_INFORMATION)*Count;
 574
 575     mapped = 0;
 576     for (i = 0; i < Count; i++)
 577     {
 578         name_size = domain_size = 0;
 579
 580         if (!LookupAccountSidW(NULL, Sids[i], NULL, &name_size, NULL, &domain_size, &use) &&
 581             GetLastError() == ERROR_INSUFFICIENT_BUFFER)
 582         {
 583             mapped++;
 584
 585             if (domain_size)
 586             {
 587                 domain.Length = (domain_size - 1) * sizeof(WCHAR);
 588                 domain.MaximumLength = domain_size * sizeof(WCHAR);
 589             }
 590             else
 591             {
 592                 /* Use a zero-length buffer */
 593                 domain.Length = 0;
 594                 domain.MaximumLength = sizeof(WCHAR);
 595             }
 596
 597             domain.Buffer = heap_alloc(domain.MaximumLength);
 598
 599             (*Names)[i].Name.Buffer = name_buffer;
 600             LookupAccountSidW(NULL, Sids[i], (*Names)[i].Name.Buffer, &name_size, domain.Buffer, &domain_size, &use);
 601             (*Names)[i].Use = use;
 602
 603             (*Names)[i].DomainIndex = lsa_reflist_add_domain(*ReferencedDomains, &domain, &domain_data);
 604             heap_free(domain.Buffer);
 605         }
 606
 607         name_buffer += name_size;
 608     }
 609     TRACE("mapped %u out of %u\n", mapped, Count);
 610
 611     if (mapped == Count) return STATUS_SUCCESS;
 612     if (mapped) return STATUS_SOME_NOT_MAPPED;
 613     return STATUS_NONE_MAPPED;
 614 }
 615
 616 /******************************************************************************
 617  * LsaNtStatusToWinError [ADVAPI32.@]
 618  *
 619  * Converts an LSA NTSTATUS code to a Windows error code.
 620  *
 621  * PARAMS
 622  *  Status [I] NTSTATUS code.
 623  *
 624  * RETURNS
 625  *  Success: Corresponding Windows error code.
 626  *  Failure: ERROR_MR_MID_NOT_FOUND.
 627  */
 628 ULONG WINAPI LsaNtStatusToWinError(NTSTATUS Status)
 629 {
 630     return RtlNtStatusToDosError(Status);
 631 }
 632
 633 /******************************************************************************
 634  * LsaOpenPolicy [ADVAPI32.@]
 635  *
 636  * Opens a handle to the Policy object on a local or remote system.
 637  *
 638  * PARAMS
 639  *  SystemName       [I] Name of the target system.
 640  *  ObjectAttributes [I] Connection attributes.
 641  *  DesiredAccess    [I] Requested access rights.
 642  *  PolicyHandle     [I/O] Handle to the Policy object.
 643  *
 644  * RETURNS
 645  *  Success: STATUS_SUCCESS.
 646  *  Failure: NTSTATUS code.
 647  *
 648  * NOTES
 649  *  Set SystemName to NULL to open the local Policy object.
 650  */
 651 NTSTATUS WINAPI LsaOpenPolicy(
 652     IN PLSA_UNICODE_STRING SystemName,
 653     IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
 654     IN ACCESS_MASK DesiredAccess,
 655     IN OUT PLSA_HANDLE PolicyHandle)
 656 {
 657     FIXME("(%s,%p,0x%08x,%p) stub\n",
 658           SystemName?debugstr_w(SystemName->Buffer):"(null)",
 659           ObjectAttributes, DesiredAccess, PolicyHandle);
 660
 661     ADVAPI_ForceLocalComputer(SystemName ? SystemName->Buffer : NULL,
 662                               STATUS_ACCESS_VIOLATION);
 663     dumpLsaAttributes(ObjectAttributes);
 664
 665     if(PolicyHandle) *PolicyHandle = (LSA_HANDLE)0xcafe;
 666     return STATUS_SUCCESS;
 667 }
 668
 669 /******************************************************************************
 670  * LsaOpenTrustedDomainByName [ADVAPI32.@]
 671  *
 672  */
 673 NTSTATUS WINAPI LsaOpenTrustedDomainByName(
 674     LSA_HANDLE policy,
 675     PLSA_UNICODE_STRING name,
 676     ACCESS_MASK access,
 677     PLSA_HANDLE handle)
 678 {
 679     FIXME("(%p,%p,0x%08x,%p) stub\n", policy, name, access, handle);
 680     return STATUS_OBJECT_NAME_NOT_FOUND;
 681 }
 682
 683 /******************************************************************************
 684  * LsaQueryInformationPolicy [ADVAPI32.@]
 685  *
 686  * Returns information about a Policy object.
 687  *
 688  * PARAMS
 689  *  PolicyHandle     [I] Handle to a Policy object.
 690  *  InformationClass [I] Type of information to retrieve.
 691  *  Buffer           [O] Pointer to the requested information.
 692  *
 693  * RETURNS
 694  *  Success: STATUS_SUCCESS.
 695  *  Failure: NTSTATUS code.
 696  */
 697 NTSTATUS WINAPI LsaQueryInformationPolicy(
 698     IN LSA_HANDLE PolicyHandle,
 699     IN POLICY_INFORMATION_CLASS InformationClass,
 700     OUT PVOID *Buffer)
 701 {
 702     TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 703
 704     if(!Buffer) return STATUS_INVALID_PARAMETER;
 705     switch (InformationClass)
 706     {
 707         case PolicyAuditEventsInformation: /* 2 */
 708         {
 709             PPOLICY_AUDIT_EVENTS_INFO p = heap_alloc_zero(sizeof(POLICY_AUDIT_EVENTS_INFO));
 710             p->AuditingMode = FALSE; /* no auditing */
 711             *Buffer = p;
 712         }
 713         break;
 714         case PolicyPrimaryDomainInformation: /* 3 */
 715         {
 716             /* Only the domain name is valid for the local computer.
 717              * All other fields are zero.
 718              */
 719             PPOLICY_PRIMARY_DOMAIN_INFO pinfo;
 720
 721             pinfo = ADVAPI_GetDomainName(sizeof(*pinfo), offsetof(POLICY_PRIMARY_DOMAIN_INFO, Name));
 722
 723             TRACE("setting domain to %s\n", debugstr_w(pinfo->Name.Buffer));
 724
 725             *Buffer = pinfo;
 726         }
 727         break;
 728         case PolicyAccountDomainInformation: /* 5 */
 729         {
 730             struct di
 731             {
 732                 POLICY_ACCOUNT_DOMAIN_INFO info;
 733                 SID sid;
 734                 DWORD padding[3];
 735                 WCHAR domain[MAX_COMPUTERNAME_LENGTH + 1];
 736             };
 737
 738             DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
 739             struct di * xdi = heap_alloc_zero(sizeof(*xdi));
 740
 741             xdi->info.DomainName.MaximumLength = dwSize * sizeof(WCHAR);
 742             xdi->info.DomainName.Buffer = xdi->domain;
 743             if (GetComputerNameW(xdi->info.DomainName.Buffer, &dwSize))
 744                 xdi->info.DomainName.Length = dwSize * sizeof(WCHAR);
 745
 746             TRACE("setting name to %s\n", debugstr_w(xdi->info.DomainName.Buffer));
 747
 748             xdi->info.DomainSid = &xdi->sid;
 749
 750             if (!ADVAPI_GetComputerSid(&xdi->sid))
 751             {
 752                 heap_free(xdi);
 753
 754                 WARN("Computer SID not found\n");
 755
 756                 return STATUS_UNSUCCESSFUL;
 757             }
 758
 759             TRACE("setting SID to %s\n", debugstr_sid(&xdi->sid));
 760
 761             *Buffer = xdi;
 762         }
 763         break;
 764         case  PolicyDnsDomainInformation:       /* 12 (0xc) */
 765         {
 766             /* Only the domain name is valid for the local computer.
 767              * All other fields are zero.
 768              */
 769             PPOLICY_DNS_DOMAIN_INFO pinfo;
 770
 771             pinfo = ADVAPI_GetDomainName(sizeof(*pinfo), offsetof(POLICY_DNS_DOMAIN_INFO, Name));
 772
 773             TRACE("setting domain to %s\n", debugstr_w(pinfo->Name.Buffer));
 774
 775             *Buffer = pinfo;
 776         }
 777         break;
 778         case  PolicyAuditLogInformation:
 779         case  PolicyPdAccountInformation:
 780         case  PolicyLsaServerRoleInformation:
 781         case  PolicyReplicaSourceInformation:
 782         case  PolicyDefaultQuotaInformation:
 783         case  PolicyModificationInformation:
 784         case  PolicyAuditFullSetInformation:
 785         case  PolicyAuditFullQueryInformation:
 786         {
 787             FIXME("category %d not implemented\n", InformationClass);
 788             return STATUS_UNSUCCESSFUL;
 789         }
 790     }
 791     return STATUS_SUCCESS;
 792 }
 793
 794 /******************************************************************************
 795  * LsaQueryTrustedDomainInfo [ADVAPI32.@]
 796  *
 797  */
 798 NTSTATUS WINAPI LsaQueryTrustedDomainInfo(
 799     LSA_HANDLE policy,
 800     PSID sid,
 801     TRUSTED_INFORMATION_CLASS class,
 802     PVOID *buffer)
 803 {
 804     FIXME("(%p,%p,%d,%p) stub\n", policy, sid, class, buffer);
 805     return STATUS_OBJECT_NAME_NOT_FOUND;
 806 }
 807
 808 /******************************************************************************
 809  * LsaQueryTrustedDomainInfoByName [ADVAPI32.@]
 810  *
 811  */
 812 NTSTATUS WINAPI LsaQueryTrustedDomainInfoByName(
 813     LSA_HANDLE policy,
 814     PLSA_UNICODE_STRING name,
 815     TRUSTED_INFORMATION_CLASS class,
 816     PVOID *buffer)
 817 {
 818     FIXME("(%p,%p,%d,%p) stub\n", policy, name, class, buffer);
 819     return STATUS_OBJECT_NAME_NOT_FOUND;
 820 }
 821
 822 /******************************************************************************
 823  * LsaRegisterPolicyChangeNotification [ADVAPI32.@]
 824  *
 825  */
 826 NTSTATUS WINAPI LsaRegisterPolicyChangeNotification(
 827     POLICY_NOTIFICATION_INFORMATION_CLASS class,
 828     HANDLE event)
 829 {
 830     FIXME("(%d,%p) stub\n", class, event);
 831     return STATUS_UNSUCCESSFUL;
 832 }
 833
 834 /******************************************************************************
 835  * LsaRemoveAccountRights [ADVAPI32.@]
 836  *
 837  */
 838 NTSTATUS WINAPI LsaRemoveAccountRights(
 839     LSA_HANDLE policy,
 840     PSID sid,
 841     BOOLEAN all,
 842     PLSA_UNICODE_STRING rights,
 843     ULONG count)
 844 {
 845     FIXME("(%p,%p,%d,%p,0x%08x) stub\n", policy, sid, all, rights, count);
 846     return STATUS_SUCCESS;
 847 }
 848
 849 /******************************************************************************
 850  * LsaRetrievePrivateData [ADVAPI32.@]
 851  *
 852  * Retrieves data stored by LsaStorePrivateData.
 853  *
 854  * PARAMS
 855  *  PolicyHandle [I] Handle to a Policy object.
 856  *  KeyName      [I] Name of the key where the data is stored.
 857  *  PrivateData  [O] Pointer to the private data.
 858  *
 859  * RETURNS
 860  *  Success: STATUS_SUCCESS.
 861  *  Failure: STATUS_OBJECT_NAME_NOT_FOUND or NTSTATUS code.
 862  */
 863 NTSTATUS WINAPI LsaRetrievePrivateData(
 864     IN LSA_HANDLE PolicyHandle,
 865     IN PLSA_UNICODE_STRING KeyName,
 866     OUT PLSA_UNICODE_STRING* PrivateData)
 867 {
 868     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 869     return STATUS_OBJECT_NAME_NOT_FOUND;
 870 }
 871
 872 /******************************************************************************
 873  * LsaSetInformationPolicy [ADVAPI32.@]
 874  *
 875  * Modifies information in a Policy object.
 876  *
 877  * PARAMS
 878  *  PolicyHandle     [I] Handle to a Policy object.
 879  *  InformationClass [I] Type of information to set.
 880  *  Buffer           [I] Pointer to the information to set.
 881  *
 882  * RETURNS
 883  *  Success: STATUS_SUCCESS.
 884  *  Failure: NTSTATUS code.
 885  */
 886 NTSTATUS WINAPI LsaSetInformationPolicy(
 887     IN LSA_HANDLE PolicyHandle,
 888     IN POLICY_INFORMATION_CLASS InformationClass,
 889     IN PVOID Buffer)
 890 {
 891     FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
 892
 893     return STATUS_UNSUCCESSFUL;
 894 }
 895
 896 /******************************************************************************
 897  * LsaSetSecret [ADVAPI32.@]
 898  *
 899  * Set old and new values on a secret handle
 900  *
 901  * PARAMS
 902  *  SecretHandle          [I] Handle to a secret object.
 903  *  EncryptedCurrentValue [I] Pointer to encrypted new value, can be NULL
 904  *  EncryptedOldValue     [I] Pointer to encrypted old value, can be NULL
 905  *
 906  * RETURNS
 907  *  Success: STATUS_SUCCESS
 908  *  Failure: NTSTATUS code.
 909  */
 910 NTSTATUS WINAPI LsaSetSecret(
 911     IN LSA_HANDLE SecretHandle,
 912     IN PLSA_UNICODE_STRING EncryptedCurrentValue,
 913     IN PLSA_UNICODE_STRING EncryptedOldValue)
 914 {
 915     FIXME("(%p,%p,%p) stub\n", SecretHandle, EncryptedCurrentValue,
 916             EncryptedOldValue);
 917     return STATUS_SUCCESS;
 918 }
 919
 920 /******************************************************************************
 921  * LsaSetTrustedDomainInfoByName [ADVAPI32.@]
 922  *
 923  */
 924 NTSTATUS WINAPI LsaSetTrustedDomainInfoByName(
 925     LSA_HANDLE policy,
 926     PLSA_UNICODE_STRING name,
 927     TRUSTED_INFORMATION_CLASS class,
 928     PVOID buffer)
 929 {
 930     FIXME("(%p,%p,%d,%p) stub\n", policy, name, class, buffer);
 931     return STATUS_SUCCESS;
 932 }
 933
 934 /******************************************************************************
 935  * LsaSetTrustedDomainInformation [ADVAPI32.@]
 936  *
 937  */
 938 NTSTATUS WINAPI LsaSetTrustedDomainInformation(
 939     LSA_HANDLE policy,
 940     PSID sid,
 941     TRUSTED_INFORMATION_CLASS class,
 942     PVOID buffer)
 943 {
 944     FIXME("(%p,%p,%d,%p) stub\n", policy, sid, class, buffer);
 945     return STATUS_SUCCESS;
 946 }
 947
 948 /******************************************************************************
 949  * LsaStorePrivateData [ADVAPI32.@]
 950  *
 951  * Stores or deletes a Policy object's data under the specified reg key.
 952  *
 953  * PARAMS
 954  *  PolicyHandle [I] Handle to a Policy object.
 955  *  KeyName      [I] Name of the key where the data will be stored.
 956  *  PrivateData  [O] Pointer to the private data.
 957  *
 958  * RETURNS
 959  *  Success: STATUS_SUCCESS.
 960  *  Failure: STATUS_OBJECT_NAME_NOT_FOUND or NTSTATUS code.
 961  */
 962 NTSTATUS WINAPI LsaStorePrivateData(
 963     IN LSA_HANDLE PolicyHandle,
 964     IN PLSA_UNICODE_STRING KeyName,
 965     IN PLSA_UNICODE_STRING PrivateData)
 966 {
 967     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 968     return STATUS_OBJECT_NAME_NOT_FOUND;
 969 }
 970
 971 /******************************************************************************
 972  * LsaUnregisterPolicyChangeNotification [ADVAPI32.@]
 973  *
 974  */
 975 NTSTATUS WINAPI LsaUnregisterPolicyChangeNotification(
 976     POLICY_NOTIFICATION_INFORMATION_CLASS class,
 977     HANDLE event)
 978 {
 979     FIXME("(%d,%p) stub\n", class, event);
 980     return STATUS_SUCCESS;
 981 }
 982
 983 /******************************************************************************
 984  * LsaLookupPrivilegeName [ADVAPI32.@]
 985  *
 986  */
 987 NTSTATUS WINAPI LsaLookupPrivilegeName(LSA_HANDLE handle, LUID *luid, LSA_UNICODE_STRING **name)
 988 {
 989     const WCHAR *privnameW;
 990     DWORD length;
 991     WCHAR *strW;
 992
 993     TRACE("(%p,%p,%p)\n", handle, luid, name);
 994
 995     if (!luid || !handle)
 996         return STATUS_INVALID_PARAMETER;
 997
 998     *name = NULL;
 999
1000     if (!(privnameW = get_wellknown_privilege_name(luid)))
1001         return STATUS_NO_SUCH_PRIVILEGE;
1002
1003     length = strlenW(privnameW);
1004     *name = heap_alloc(sizeof(**name) + (length + 1) * sizeof(WCHAR));
1005     if (!*name)
1006         return STATUS_NO_MEMORY;
1007
1008     strW = (WCHAR *)(*name + 1);
1009     memcpy(strW, privnameW, length * sizeof(WCHAR));
1010     strW[length] = 0;
1011     RtlInitUnicodeString(*name, strW);
1012
1013     return STATUS_SUCCESS;
1014 }
1015
1016 /******************************************************************************
1017  * LsaLookupPrivilegeDisplayName [ADVAPI32.@]
1018  *
1019  */
1020 NTSTATUS WINAPI LsaLookupPrivilegeDisplayName(LSA_HANDLE handle, LSA_UNICODE_STRING *name,
1021     LSA_UNICODE_STRING **display_name, SHORT *language)
1022 {
1023     FIXME("(%p, %s, %p, %p)\n", handle, debugstr_us(name), display_name, language);
1024
1025     return STATUS_NO_SUCH_PRIVILEGE;
1026 }