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
  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 void dumpLsaAttributes(PLSA_OBJECT_ATTRIBUTES oa)
  48 {
  49     if (oa)
  50     {
  51         TRACE("\n\tlength=%lu, rootdir=%p, objectname=%s\n\tattr=0x%08lx, sid=%p qos=%p\n",
  52               oa->Length, oa->RootDirectory,
  53               oa->ObjectName?debugstr_w(oa->ObjectName->Buffer):"null",
  54               oa->Attributes, oa->SecurityDescriptor, oa->SecurityQualityOfService);
  55     }
  56 }
  57
  58 /******************************************************************************
  59  * LsaAddAccountRights [ADVAPI32.@]
  60  *
  61  */
  62 NTSTATUS WINAPI LsaAddAccountRights(
  63     LSA_HANDLE policy,
  64     PSID sid,
  65     PLSA_UNICODE_STRING rights,
  66     ULONG count)
  67 {
  68     FIXME("(%p,%p,%p,0x%08lx) stub\n", policy, sid, rights, count);
  69     return STATUS_OBJECT_NAME_NOT_FOUND;
  70 }
  71
  72 /******************************************************************************
  73  * LsaClose [ADVAPI32.@]
  74  *
  75  * Closes a handle to a Policy or TrustedDomain.
  76  *
  77  * PARAMS
  78  *  ObjectHandle [I] Handle to a Policy or TrustedDomain.
  79  *
  80  * RETURNS
  81  *  Success: STATUS_SUCCESS.
  82  *  Failure: NTSTATUS code.
  83  */
  84 NTSTATUS WINAPI LsaClose(IN LSA_HANDLE ObjectHandle)
  85 {
  86     FIXME("(%p) stub\n", ObjectHandle);
  87     return STATUS_SUCCESS;
  88 }
  89
  90 /******************************************************************************
  91  * LsaCreateTrustedDomainEx [ADVAPI32.@]
  92  *
  93  */
  94 NTSTATUS WINAPI LsaCreateTrustedDomainEx(
  95     LSA_HANDLE policy,
  96     PTRUSTED_DOMAIN_INFORMATION_EX domain_info,
  97     PTRUSTED_DOMAIN_AUTH_INFORMATION auth_info,
  98     ACCESS_MASK access,
  99     PLSA_HANDLE domain)
 100 {
 101     FIXME("(%p,%p,%p,0x%08lx,%p) stub\n", policy, domain_info, auth_info,
 102           access, domain);
 103     return STATUS_SUCCESS;
 104 }
 105
 106 /******************************************************************************
 107  * LsaDeleteTrustedDomain [ADVAPI32.@]
 108  *
 109  */
 110 NTSTATUS WINAPI LsaDeleteTrustedDomain(LSA_HANDLE policy, PSID sid)
 111 {
 112     FIXME("(%p,%p) stub\n", policy, sid);
 113     return STATUS_SUCCESS;
 114 }
 115
 116 /******************************************************************************
 117  * LsaEnumerateAccountRights [ADVAPI32.@]
 118  *
 119  */
 120 NTSTATUS WINAPI LsaEnumerateAccountRights(
 121     LSA_HANDLE policy,
 122     PSID sid,
 123     PLSA_UNICODE_STRING *rights,
 124     PULONG count)
 125 {
 126     FIXME("(%p,%p,%p,%p) stub\n", policy, sid, rights, count);
 127     return STATUS_OBJECT_NAME_NOT_FOUND;
 128 }
 129
 130 /******************************************************************************
 131  * LsaEnumerateAccountsWithUserRight [ADVAPI32.@]
 132  *
 133  */
 134 NTSTATUS WINAPI LsaEnumerateAccountsWithUserRight(
 135     LSA_HANDLE policy,
 136     PLSA_UNICODE_STRING rights,
 137     PVOID *buffer,
 138     PULONG count)
 139 {
 140     FIXME("(%p,%p,%p,%p) stub\n", policy, rights, buffer, count);
 141     return STATUS_NO_MORE_ENTRIES;
 142 }
 143
 144 /******************************************************************************
 145  * LsaEnumerateTrustedDomains [ADVAPI32.@]
 146  *
 147  * Returns the names and SIDs of trusted domains.
 148  *
 149  * PARAMS
 150  *  PolicyHandle          [I] Handle to a Policy object.
 151  *  EnumerationContext    [I] Pointer to an enumeration handle.
 152  *  Buffer                [O] Contains the names and SIDs of trusted domains.
 153  *  PreferredMaximumLength[I] Preferred maximum size in bytes of Buffer.
 154  *  CountReturned         [O] Number of elements in Buffer.
 155  *
 156  * RETURNS
 157  *  Success: STATUS_SUCCESS,
 158  *           STATUS_MORE_ENTRIES,
 159  *           STATUS_NO_MORE_ENTRIES
 160  *  Failure: NTSTATUS code.
 161  *
 162  * NOTES
 163  *  LsaEnumerateTrustedDomains can be called multiple times to enumerate
 164  *  all trusted domains.
 165  */
 166 NTSTATUS WINAPI LsaEnumerateTrustedDomains(
 167     IN LSA_HANDLE PolicyHandle,
 168     IN PLSA_ENUMERATION_HANDLE EnumerationContext,
 169     OUT PVOID* Buffer,
 170     IN ULONG PreferredMaximumLength,
 171     OUT PULONG CountReturned)
 172 {
 173     FIXME("(%p,%p,%p,0x%08lx,%p) stub\n", PolicyHandle, EnumerationContext,
 174           Buffer, PreferredMaximumLength, CountReturned);
 175
 176     if (CountReturned) *CountReturned = 0;
 177     return STATUS_SUCCESS;
 178 }
 179
 180 /******************************************************************************
 181  * LsaEnumerateTrustedDomainsEx [ADVAPI32.@]
 182  *
 183  */
 184 NTSTATUS WINAPI LsaEnumerateTrustedDomainsEx(
 185     LSA_HANDLE policy,
 186     PLSA_ENUMERATION_HANDLE context,
 187     PVOID *buffer,
 188     ULONG length,
 189     PULONG count)
 190 {
 191     FIXME("(%p,%p,%p,0x%08lx,%p) stub\n", policy, context, buffer, length, count);
 192
 193     if (count) *count = 0;
 194     return STATUS_SUCCESS;
 195 }
 196
 197 /******************************************************************************
 198  * LsaFreeMemory [ADVAPI32.@]
 199  *
 200  * Frees memory allocated by a LSA function.
 201  *
 202  * PARAMS
 203  *  Buffer [I] Memory buffer to free.
 204  *
 205  * RETURNS
 206  *  Success: STATUS_SUCCESS.
 207  *  Failure: NTSTATUS code.
 208  */
 209 NTSTATUS WINAPI LsaFreeMemory(IN PVOID Buffer)
 210 {
 211     TRACE("(%p)\n", Buffer);
 212     return HeapFree(GetProcessHeap(), 0, Buffer);
 213 }
 214
 215 /******************************************************************************
 216  * LsaLookupNames [ADVAPI32.@]
 217  *
 218  * Returns the SIDs of an array of user, group, or local group names.
 219  *
 220  * PARAMS
 221  *  PolicyHandle      [I] Handle to a Policy object.
 222  *  Count             [I] Number of names in Names.
 223  *  Names             [I] Array of names to lookup.
 224  *  ReferencedDomains [O] Array of domains where the names were found.
 225  *  Sids              [O] Array of SIDs corresponding to Names.
 226  *
 227  * RETURNS
 228  *  Success: STATUS_SUCCESS,
 229  *           STATUS_SOME_NOT_MAPPED
 230  *  Failure: STATUS_NONE_MAPPED or NTSTATUS code.
 231  */
 232 NTSTATUS WINAPI LsaLookupNames(
 233     IN LSA_HANDLE PolicyHandle,
 234     IN ULONG Count,
 235     IN PLSA_UNICODE_STRING Names,
 236     OUT PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains,
 237     OUT PLSA_TRANSLATED_SID* Sids)
 238 {
 239     FIXME("(%p,0x%08lx,%p,%p,%p) stub\n", PolicyHandle, Count, Names,
 240           ReferencedDomains, Sids);
 241
 242     return STATUS_NONE_MAPPED;
 243 }
 244
 245 /******************************************************************************
 246  * LsaLookupNames2 [ADVAPI32.@]
 247  *
 248  */
 249 NTSTATUS WINAPI LsaLookupNames2(
 250     LSA_HANDLE policy,
 251     ULONG flags,
 252     ULONG count,
 253     PLSA_UNICODE_STRING names,
 254     PLSA_REFERENCED_DOMAIN_LIST *domains,
 255     PLSA_TRANSLATED_SID2 *sids)
 256 {
 257     FIXME("(%p,0x%08lx,0x%08lx,%p,%p,%p) stub\n", policy, flags, count, names, domains, sids);
 258     return STATUS_NONE_MAPPED;
 259 }
 260
 261 /******************************************************************************
 262  * LsaLookupSids [ADVAPI32.@]
 263  *
 264  * Looks up the names that correspond to an array of SIDs.
 265  *
 266  * PARAMS
 267  *  PolicyHandle      [I] Handle to a Policy object.
 268  *  Count             [I] Number of SIDs in the Sids array.
 269  *  Sids              [I] Array of SIDs to lookup.
 270  *  ReferencedDomains [O] Array of domains where the sids were found.
 271  *  Names             [O] Array of names corresponding to Sids.
 272  *
 273  * RETURNS
 274  *  Success: STATUS_SUCCESS,
 275  *           STATUS_SOME_NOT_MAPPED
 276  *  Failure: STATUS_NONE_MAPPED or NTSTATUS code.
 277  */
 278 NTSTATUS WINAPI LsaLookupSids(
 279     IN LSA_HANDLE PolicyHandle,
 280     IN ULONG Count,
 281     IN PSID *Sids,
 282     OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 283     OUT PLSA_TRANSLATED_NAME *Names )
 284 {
 285     FIXME("(%p,%lu,%p,%p,%p) stub\n", PolicyHandle, Count, Sids,
 286           ReferencedDomains, Names);
 287
 288     return STATUS_NONE_MAPPED;
 289 }
 290
 291 /******************************************************************************
 292  * LsaNtStatusToWinError [ADVAPI32.@]
 293  *
 294  * Converts an LSA NTSTATUS code to a Windows error code.
 295  *
 296  * PARAMS
 297  *  Status [I] NTSTATUS code.
 298  *
 299  * RETURNS
 300  *  Success: Corresponding Windows error code.
 301  *  Failure: ERROR_MR_MID_NOT_FOUND.
 302  */
 303 ULONG WINAPI LsaNtStatusToWinError(NTSTATUS Status)
 304 {
 305     return RtlNtStatusToDosError(Status);
 306 }
 307
 308 /******************************************************************************
 309  * LsaOpenPolicy [ADVAPI32.@]
 310  *
 311  * Opens a handle to the Policy object on a local or remote system.
 312  *
 313  * PARAMS
 314  *  SystemName       [I] Name of the target system.
 315  *  ObjectAttributes [I] Connection attributes.
 316  *  DesiredAccess    [I] Requested access rights.
 317  *  PolicyHandle     [I/O] Handle to the Policy object.
 318  *
 319  * RETURNS
 320  *  Success: STATUS_SUCCESS.
 321  *  Failure: NTSTATUS code.
 322  *
 323  * NOTES
 324  *  Set SystemName to NULL to open the local Policy object.
 325  */
 326 NTSTATUS WINAPI LsaOpenPolicy(
 327     IN PLSA_UNICODE_STRING SystemName,
 328     IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
 329     IN ACCESS_MASK DesiredAccess,
 330     IN OUT PLSA_HANDLE PolicyHandle)
 331 {
 332     FIXME("(%s,%p,0x%08lx,%p) stub\n",
 333           SystemName?debugstr_w(SystemName->Buffer):"(null)",
 334           ObjectAttributes, DesiredAccess, PolicyHandle);
 335
 336     ADVAPI_ForceLocalComputer(SystemName ? SystemName->Buffer : NULL,
 337                               STATUS_ACCESS_VIOLATION);
 338     dumpLsaAttributes(ObjectAttributes);
 339
 340     if(PolicyHandle) *PolicyHandle = (LSA_HANDLE)0xcafe;
 341     return STATUS_SUCCESS;
 342 }
 343
 344 /******************************************************************************
 345  * LsaOpenTrustedDomainByName [ADVAPI32.@]
 346  *
 347  */
 348 NTSTATUS WINAPI LsaOpenTrustedDomainByName(
 349     LSA_HANDLE policy,
 350     PLSA_UNICODE_STRING name,
 351     ACCESS_MASK access,
 352     PLSA_HANDLE handle)
 353 {
 354     FIXME("(%p,%p,0x%08lx,%p) stub\n", policy, name, access, handle);
 355     return STATUS_OBJECT_NAME_NOT_FOUND;
 356 }
 357
 358 /******************************************************************************
 359  * LsaQueryInformationPolicy [ADVAPI32.@]
 360  *
 361  * Returns information about a Policy object.
 362  *
 363  * PARAMS
 364  *  PolicyHandle     [I] Handle to a Policy object.
 365  *  InformationClass [I] Type of information to retrieve.
 366  *  Buffer           [O] Pointer to the requested information.
 367  *
 368  * RETURNS
 369  *  Success: STATUS_SUCCESS.
 370  *  Failure: NTSTATUS code.
 371  */
 372 NTSTATUS WINAPI LsaQueryInformationPolicy(
 373     IN LSA_HANDLE PolicyHandle,
 374     IN POLICY_INFORMATION_CLASS InformationClass,
 375     OUT PVOID *Buffer)
 376 {
 377     TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
 378
 379     if(!Buffer) return STATUS_INVALID_PARAMETER;
 380     switch (InformationClass)
 381     {
 382         case PolicyAuditEventsInformation: /* 2 */
 383         {
 384             PPOLICY_AUDIT_EVENTS_INFO p = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 385                                                     sizeof(POLICY_AUDIT_EVENTS_INFO));
 386             p->AuditingMode = FALSE; /* no auditing */
 387             *Buffer = p;
 388         }
 389         break;
 390         case PolicyPrimaryDomainInformation: /* 3 */
 391         {
 392             /* Only the domain name is valid for the local computer.
 393              * All other fields are zero.
 394              */
 395             PPOLICY_PRIMARY_DOMAIN_INFO pinfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 396                                                           sizeof(POLICY_PRIMARY_DOMAIN_INFO));
 397             HKEY key;
 398             BOOL useDefault = TRUE;
 399             LONG ret;
 400
 401             if ((ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
 402                  "System\\CurrentControlSet\\Services\\VxD\\VNETSUP", 0,
 403                  KEY_READ, &key)) == ERROR_SUCCESS)
 404             {
 405                 DWORD size = 0;
 406                 static const WCHAR wg[] = { 'W','o','r','k','g','r','o','u','p',0 };
 407
 408                 ret = RegQueryValueExW(key, wg, NULL, NULL, NULL, &size);
 409                 if (ret == ERROR_MORE_DATA || ret == ERROR_SUCCESS)
 410                 {
 411                     pinfo->Name.Buffer = HeapAlloc(GetProcessHeap(),
 412                                                    HEAP_ZERO_MEMORY, size);
 413
 414                     if ((ret = RegQueryValueExW(key, wg, NULL, NULL,
 415                          (LPBYTE)pinfo->Name.Buffer, &size)) == ERROR_SUCCESS)
 416                     {
 417                         pinfo->Name.Length = (USHORT)(size - sizeof(WCHAR));
 418                         pinfo->Name.MaximumLength = (USHORT)size;
 419                         useDefault = FALSE;
 420                     }
 421                     else
 422                     {
 423                         HeapFree(GetProcessHeap(), 0, pinfo->Name.Buffer);
 424                         pinfo->Name.Buffer = NULL;
 425                     }
 426                 }
 427                 RegCloseKey(key);
 428             }
 429             if (useDefault)
 430                 RtlCreateUnicodeStringFromAsciiz(&(pinfo->Name), "DOMAIN");
 431
 432             TRACE("setting domain to %s\n", debugstr_w(pinfo->Name.Buffer));
 433
 434             *Buffer = pinfo;
 435         }
 436         break;
 437         case PolicyAccountDomainInformation: /* 5 */
 438         {
 439             struct di
 440             {
 441                 POLICY_ACCOUNT_DOMAIN_INFO info;
 442                 SID sid;
 443                 DWORD padding[3];
 444             };
 445
 446             struct di * xdi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*xdi));
 447             DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
 448             LPWSTR buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwSize * sizeof(WCHAR));
 449
 450             xdi->info.DomainName.MaximumLength = dwSize * sizeof(WCHAR);
 451
 452             if (GetComputerNameW(buf, &dwSize))
 453             {
 454                 xdi->info.DomainName.Buffer = buf;
 455                 xdi->info.DomainName.Length = dwSize * sizeof(WCHAR);
 456             }
 457
 458             TRACE("setting name to %s\n", debugstr_w(xdi->info.DomainName.Buffer));
 459
 460             xdi->info.DomainSid = &(xdi->sid);
 461
 462             /* read the computer SID from the registry */
 463             if (!ADVAPI_GetComputerSid(&(xdi->sid)))
 464             {
 465                 HeapFree(GetProcessHeap(), 0, buf);
 466                 HeapFree(GetProcessHeap(), 0, xdi);
 467
 468                 WARN("Computer SID not found\n");
 469
 470                 return STATUS_UNSUCCESSFUL;
 471             }
 472
 473             TRACE("setting SID to %s\n", debugstr_sid(&xdi->sid));
 474
 475             *Buffer = xdi;
 476         }
 477         break;
 478         case  PolicyDnsDomainInformation:       /* 12 (0xc) */
 479         {
 480             /* Only the domain name is valid for the local computer.
 481              * All other fields are zero.
 482              */
 483             PPOLICY_DNS_DOMAIN_INFO pinfo = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 484                                                       sizeof(POLICY_DNS_DOMAIN_INFO));
 485             HKEY key;
 486             BOOL useDefault = TRUE;
 487             LONG ret;
 488
 489             if ((ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
 490                  "System\\CurrentControlSet\\Services\\VxD\\VNETSUP", 0,
 491                  KEY_READ, &key)) == ERROR_SUCCESS)
 492             {
 493                 DWORD size = 0;
 494                 static const WCHAR wg[] = { 'W','o','r','k','g','r','o','u','p',0 };
 495
 496                 ret = RegQueryValueExW(key, wg, NULL, NULL, NULL, &size);
 497                 if (ret == ERROR_MORE_DATA || ret == ERROR_SUCCESS)
 498                 {
 499                     pinfo->Name.Buffer = HeapAlloc(GetProcessHeap(),
 500                                                    HEAP_ZERO_MEMORY, size);
 501
 502                     if ((ret = RegQueryValueExW(key, wg, NULL, NULL,
 503                          (LPBYTE)pinfo->Name.Buffer, &size)) == ERROR_SUCCESS)
 504                     {
 505                         pinfo->Name.Length = (USHORT)(size - sizeof(WCHAR));
 506                         pinfo->Name.MaximumLength = (USHORT)size;
 507                         useDefault = FALSE;
 508                     }
 509                     else
 510                     {
 511                         HeapFree(GetProcessHeap(), 0, pinfo->Name.Buffer);
 512                         pinfo->Name.Buffer = NULL;
 513                     }
 514                 }
 515                 RegCloseKey(key);
 516             }
 517             if (useDefault)
 518                 RtlCreateUnicodeStringFromAsciiz(&(pinfo->Name), "DOMAIN");
 519
 520             TRACE("setting domain to %s\n", debugstr_w(pinfo->Name.Buffer));
 521
 522             *Buffer = pinfo;
 523         }
 524         break;
 525         case  PolicyAuditLogInformation:
 526         case  PolicyPdAccountInformation:
 527         case  PolicyLsaServerRoleInformation:
 528         case  PolicyReplicaSourceInformation:
 529         case  PolicyDefaultQuotaInformation:
 530         case  PolicyModificationInformation:
 531         case  PolicyAuditFullSetInformation:
 532         case  PolicyAuditFullQueryInformation:
 533         {
 534             FIXME("category %d not implemented\n", InformationClass);
 535             return STATUS_UNSUCCESSFUL;
 536         }
 537     }
 538     return STATUS_SUCCESS;
 539 }
 540
 541 /******************************************************************************
 542  * LsaQueryTrustedDomainInfo [ADVAPI32.@]
 543  *
 544  */
 545 NTSTATUS WINAPI LsaQueryTrustedDomainInfo(
 546     LSA_HANDLE policy,
 547     PSID sid,
 548     TRUSTED_INFORMATION_CLASS class,
 549     PVOID *buffer)
 550 {
 551     FIXME("(%p,%p,%d,%p) stub\n", policy, sid, class, buffer);
 552     return STATUS_OBJECT_NAME_NOT_FOUND;
 553 }
 554
 555 /******************************************************************************
 556  * LsaQueryTrustedDomainInfoByName [ADVAPI32.@]
 557  *
 558  */
 559 NTSTATUS WINAPI LsaQueryTrustedDomainInfoByName(
 560     LSA_HANDLE policy,
 561     PLSA_UNICODE_STRING name,
 562     TRUSTED_INFORMATION_CLASS class,
 563     PVOID *buffer)
 564 {
 565     FIXME("(%p,%p,%d,%p) stub\n", policy, name, class, buffer);
 566     return STATUS_OBJECT_NAME_NOT_FOUND;
 567 }
 568
 569 /******************************************************************************
 570  * LsaRegisterPolicyChangeNotification [ADVAPI32.@]
 571  *
 572  */
 573 NTSTATUS WINAPI LsaRegisterPolicyChangeNotification(
 574     POLICY_NOTIFICATION_INFORMATION_CLASS class,
 575     HANDLE event)
 576 {
 577     FIXME("(%d,%p) stub\n", class, event);
 578     return STATUS_UNSUCCESSFUL;
 579 }
 580
 581 /******************************************************************************
 582  * LsaRemoveAccountRights [ADVAPI32.@]
 583  *
 584  */
 585 NTSTATUS WINAPI LsaRemoveAccountRights(
 586     LSA_HANDLE policy,
 587     PSID sid,
 588     BOOLEAN all,
 589     PLSA_UNICODE_STRING rights,
 590     ULONG count)
 591 {
 592     FIXME("(%p,%p,%d,%p,0x%08lx) stub\n", policy, sid, all, rights, count);
 593     return STATUS_SUCCESS;
 594 }
 595
 596 /******************************************************************************
 597  * LsaRetrievePrivateData [ADVAPI32.@]
 598  *
 599  * Retrieves data stored by LsaStorePrivateData.
 600  *
 601  * PARAMS
 602  *  PolicyHandle [I] Handle to a Policy object.
 603  *  KeyName      [I] Name of the key where the data is stored.
 604  *  PrivateData  [O] Pointer to the private data.
 605  *
 606  * RETURNS
 607  *  Success: STATUS_SUCCESS.
 608  *  Failure: STATUS_OBJECT_NAME_NOT_FOUND or NTSTATUS code.
 609  */
 610 NTSTATUS WINAPI LsaRetrievePrivateData(
 611     IN LSA_HANDLE PolicyHandle,
 612     IN PLSA_UNICODE_STRING KeyName,
 613     OUT PLSA_UNICODE_STRING* PrivateData)
 614 {
 615     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 616     return STATUS_OBJECT_NAME_NOT_FOUND;
 617 }
 618
 619 /******************************************************************************
 620  * LsaSetInformationPolicy [ADVAPI32.@]
 621  *
 622  * Modifies information in a Policy object.
 623  *
 624  * PARAMS
 625  *  PolicyHandle     [I] Handle to a Policy object.
 626  *  InformationClass [I] Type of information to set.
 627  *  Buffer           [I] Pointer to the information to set.
 628  *
 629  * RETURNS
 630  *  Success: STATUS_SUCCESS.
 631  *  Failure: NTSTATUS code.
 632  */
 633 NTSTATUS WINAPI LsaSetInformationPolicy(
 634     IN LSA_HANDLE PolicyHandle,
 635     IN POLICY_INFORMATION_CLASS InformationClass,
 636     IN PVOID Buffer)
 637 {
 638     FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
 639
 640     return STATUS_UNSUCCESSFUL;
 641 }
 642
 643 /******************************************************************************
 644  * LsaSetTrustedDomainInfoByName [ADVAPI32.@]
 645  *
 646  */
 647 NTSTATUS WINAPI LsaSetTrustedDomainInfoByName(
 648     LSA_HANDLE policy,
 649     PLSA_UNICODE_STRING name,
 650     TRUSTED_INFORMATION_CLASS class,
 651     PVOID buffer)
 652 {
 653     FIXME("(%p,%p,%d,%p) stub\n", policy, name, class, buffer);
 654     return STATUS_SUCCESS;
 655 }
 656
 657 /******************************************************************************
 658  * LsaSetTrustedDomainInformation [ADVAPI32.@]
 659  *
 660  */
 661 NTSTATUS WINAPI LsaSetTrustedDomainInformation(
 662     LSA_HANDLE policy,
 663     PSID sid,
 664     TRUSTED_INFORMATION_CLASS class,
 665     PVOID buffer)
 666 {
 667     FIXME("(%p,%p,%d,%p) stub\n", policy, sid, class, buffer);
 668     return STATUS_SUCCESS;
 669 }
 670
 671 /******************************************************************************
 672  * LsaStorePrivateData [ADVAPI32.@]
 673  *
 674  * Stores or deletes a Policy object's data under the specified reg key.
 675  *
 676  * PARAMS
 677  *  PolicyHandle [I] Handle to a Policy object.
 678  *  KeyName      [I] Name of the key where the data will be stored.
 679  *  PrivateData  [O] Pointer to the private data.
 680  *
 681  * RETURNS
 682  *  Success: STATUS_SUCCESS.
 683  *  Failure: STATUS_OBJECT_NAME_NOT_FOUND or NTSTATUS code.
 684  */
 685 NTSTATUS WINAPI LsaStorePrivateData(
 686     IN LSA_HANDLE PolicyHandle,
 687     IN PLSA_UNICODE_STRING KeyName,
 688     IN PLSA_UNICODE_STRING PrivateData)
 689 {
 690     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 691     return STATUS_OBJECT_NAME_NOT_FOUND;
 692 }
 693
 694 /******************************************************************************
 695  * LsaUnregisterPolicyChangeNotification [ADVAPI32.@]
 696  *
 697  */
 698 NTSTATUS WINAPI LsaUnregisterPolicyChangeNotification(
 699     POLICY_NOTIFICATION_INFORMATION_CLASS class,
 700     HANDLE event)
 701 {
 702     FIXME("(%d,%p) stub\n", class, event);
 703     return STATUS_SUCCESS;
 704 }