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