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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
  37
  38 #define ADVAPI_ForceLocalComputer(ServerName, FailureCode) \
  39     if (!ADVAPI_IsLocalComputer(ServerName)) \
  40 { \
  41         FIXME("Action Implemented for local computer only. " \
  42               "Requested for server %s\n", debugstr_w(ServerName)); \
  43         return FailureCode; \
  44 }
  45
  46 static void dumpLsaAttributes(PLSA_OBJECT_ATTRIBUTES oa)
  47 {
  48     if (oa)
  49     {
  50         TRACE("\n\tlength=%lu, rootdir=%p, objectname=%s\n\tattr=0x%08lx, sid=%p qos=%p\n",
  51               oa->Length, oa->RootDirectory,
  52               oa->ObjectName?debugstr_w(oa->ObjectName->Buffer):"null",
  53               oa->Attributes, oa->SecurityDescriptor, oa->SecurityQualityOfService);
  54     }
  55 }
  56
  57 /************************************************************
  58  * ADVAPI_IsLocalComputer
  59  *
  60  * Checks whether the server name indicates local machine.
  61  */
  62 static BOOL ADVAPI_IsLocalComputer(LPCWSTR ServerName)
  63 {
  64     DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
  65     BOOL Result;
  66     LPWSTR buf;
  67
  68     if (!ServerName || !ServerName[0])
  69         return TRUE;
  70
  71     buf = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
  72     Result = GetComputerNameW(buf,  &dwSize);
  73     if (Result && (ServerName[0] == '\\') && (ServerName[1] == '\\'))
  74         ServerName += 2;
  75     Result = Result && !lstrcmpW(ServerName, buf);
  76     HeapFree(GetProcessHeap(), 0, buf);
  77
  78     return Result;
  79 }
  80
  81 /******************************************************************************
  82  * LsaClose [ADVAPI32.@]
  83  *
  84  * Closes a handle to a Policy or TrustedDomain.
  85  *
  86  * PARAMS
  87  *  ObjectHandle [I] Handle to a Policy or TrustedDomain.
  88  *
  89  * RETURNS
  90  *  Success: STATUS_SUCCESS.
  91  *  Failure: NTSTATUS code.
  92  */
  93 NTSTATUS WINAPI LsaClose(IN LSA_HANDLE ObjectHandle)
  94 {
  95     FIXME("(%p) stub\n", ObjectHandle);
  96     return 0xc0000000;
  97 }
  98
  99 /******************************************************************************
 100  * LsaEnumerateTrustedDomains [ADVAPI32.@]
 101  *
 102  * Returns the names and SIDs of trusted domains.
 103  *
 104  * PARAMS
 105  *  PolicyHandle          [I] Handle to a Policy object.
 106  *  EnumerationContext    [I] Pointer to an enumeration handle.
 107  *  Buffer                [O] Contains the names and SIDs of trusted domains.
 108  *  PreferredMaximumLength[I] Preferred maximum size in bytes of Buffer.
 109  *  CountReturned         [O] Number of elements in Buffer.
 110  *
 111  * RETURNS
 112  *  Success: STATUS_SUCCESS,
 113  *           STATUS_MORE_ENTRIES,
 114  *           STATUS_NO_MORE_ENTRIES
 115  *  Failure: NTSTATUS code.
 116  *
 117  * NOTES
 118  *  LsaEnumerateTrustedDomains can be called multiple times to enumerate
 119  *  all trusted domains.
 120  */
 121 NTSTATUS WINAPI LsaEnumerateTrustedDomains(
 122     IN LSA_HANDLE PolicyHandle,
 123     IN PLSA_ENUMERATION_HANDLE EnumerationContext,
 124     OUT PVOID* Buffer,
 125     IN ULONG PreferredMaximumLength,
 126     OUT PULONG CountReturned)
 127 {
 128     FIXME("(%p,%p,%p,0x%08lx,%p) stub\n", PolicyHandle, EnumerationContext,
 129           Buffer, PreferredMaximumLength, CountReturned);
 130
 131     if (CountReturned) *CountReturned = 0;
 132     return STATUS_SUCCESS;
 133 }
 134
 135 /******************************************************************************
 136  * LsaFreeMemory [ADVAPI32.@]
 137  *
 138  * Frees memory allocated by a LSA function.
 139  *
 140  * PARAMS
 141  *  Buffer [I] Memory buffer to free.
 142  *
 143  * RETURNS
 144  *  Success: STATUS_SUCCESS.
 145  *  Failure: NTSTATUS code.
 146  */
 147 NTSTATUS WINAPI LsaFreeMemory(IN PVOID Buffer)
 148 {
 149     TRACE("(%p)\n", Buffer);
 150     return HeapFree(GetProcessHeap(), 0, Buffer);
 151 }
 152
 153 /******************************************************************************
 154  * LsaLookupNames [ADVAPI32.@]
 155  *
 156  * Returns the SIDs of an array of user, group, or local group names.
 157  *
 158  * PARAMS
 159  *  PolicyHandle      [I] Handle to a Policy object.
 160  *  Count             [I] Number of names in Names.
 161  *  Names             [I] Array of names to lookup.
 162  *  ReferencedDomains [O] Array of domains where the names were found.
 163  *  Sids              [O] Array of SIDs corresponding to Names.
 164  *
 165  * RETURNS
 166  *  Success: STATUS_SUCCESS,
 167  *           STATUS_SOME_NOT_MAPPED
 168  *  Failure: STATUS_NONE_MAPPED or NTSTATUS code.
 169  */
 170 NTSTATUS WINAPI LsaLookupNames(
 171     IN LSA_HANDLE PolicyHandle,
 172     IN ULONG Count,
 173     IN PLSA_UNICODE_STRING Names,
 174     OUT PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains,
 175     OUT PLSA_TRANSLATED_SID* Sids)
 176 {
 177     FIXME("(%p,0x%08lx,%p,%p,%p) stub\n", PolicyHandle, Count, Names,
 178           ReferencedDomains, Sids);
 179
 180     return STATUS_NONE_MAPPED;
 181 }
 182
 183 /******************************************************************************
 184  * LsaLookupSids [ADVAPI32.@]
 185  *
 186  * Looks up the names that correspond to an array of SIDs.
 187  *
 188  * PARAMS
 189  *  PolicyHandle      [I] Handle to a Policy object.
 190  *  Count             [I] Number of SIDs in the Sids array.
 191  *  Sids              [I] Array of SIDs to lookup.
 192  *  ReferencedDomains [O] Array of domains where the sids were found.
 193  *  Names             [O] Array of names corresponding to Sids.
 194  *
 195  * RETURNS
 196  *  Success: STATUS_SUCCESS,
 197  *           STATUS_SOME_NOT_MAPPED
 198  *  Failure: STATUS_NONE_MAPPED or NTSTATUS code.
 199  */
 200 NTSTATUS WINAPI LsaLookupSids(
 201     IN LSA_HANDLE PolicyHandle,
 202     IN ULONG Count,
 203     IN PSID *Sids,
 204     OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
 205     OUT PLSA_TRANSLATED_NAME *Names )
 206 {
 207     FIXME("(%p,%lu,%p,%p,%p) stub\n", PolicyHandle, Count, Sids,
 208           ReferencedDomains, Names);
 209
 210     return STATUS_NONE_MAPPED;
 211 }
 212
 213 /******************************************************************************
 214  * LsaNtStatusToWinError [ADVAPI32.@]
 215  *
 216  * Converts an LSA NTSTATUS code to a Windows error code.
 217  *
 218  * PARAMS
 219  *  Status [I] NTSTATUS code.
 220  *
 221  * RETURNS
 222  *  Success: Corresponding Windows error code.
 223  *  Failure: ERROR_MR_MID_NOT_FOUND.
 224  */
 225 ULONG WINAPI LsaNtStatusToWinError(NTSTATUS Status)
 226 {
 227     return RtlNtStatusToDosError(Status);
 228 }
 229
 230 /******************************************************************************
 231  * LsaOpenPolicy [ADVAPI32.@]
 232  *
 233  * Opens a handle to the Policy object on a local or remote system.
 234  *
 235  * PARAMS
 236  *  SystemName       [I] Name of the target system.
 237  *  ObjectAttributes [I] Connection attributes.
 238  *  DesiredAccess    [I] Requested access rights.
 239  *  PolicyHandle     [I/O] Handle to the Policy object.
 240  *
 241  * RETURNS
 242  *  Success: STATUS_SUCCESS.
 243  *  Failure: NTSTATUS code.
 244  *
 245  * NOTES
 246  *  Set SystemName to NULL to open the local Policy object.
 247  */
 248 NTSTATUS WINAPI LsaOpenPolicy(
 249     IN PLSA_UNICODE_STRING SystemName,
 250     IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
 251     IN ACCESS_MASK DesiredAccess,
 252     IN OUT PLSA_HANDLE PolicyHandle)
 253 {
 254     FIXME("(%s,%p,0x%08lx,%p) stub\n",
 255           SystemName?debugstr_w(SystemName->Buffer):"(null)",
 256           ObjectAttributes, DesiredAccess, PolicyHandle);
 257
 258     ADVAPI_ForceLocalComputer(SystemName ? SystemName->Buffer : NULL,
 259                               STATUS_ACCESS_VIOLATION);
 260     dumpLsaAttributes(ObjectAttributes);
 261
 262     if(PolicyHandle) *PolicyHandle = (LSA_HANDLE)0xcafe;
 263     return STATUS_SUCCESS;
 264 }
 265
 266 /******************************************************************************
 267  * LsaQueryInformationPolicy [ADVAPI32.@]
 268  *
 269  * Returns information about a Policy object.
 270  *
 271  * PARAMS
 272  *  PolicyHandle     [I] Handle to a Policy object.
 273  *  InformationClass [I] Type of information to retrieve.
 274  *  Buffer           [O] Pointer to the requested information.
 275  *
 276  * RETURNS
 277  *  Success: STATUS_SUCCESS.
 278  *  Failure: NTSTATUS code.
 279  */
 280 NTSTATUS WINAPI LsaQueryInformationPolicy(
 281     IN LSA_HANDLE PolicyHandle,
 282     IN POLICY_INFORMATION_CLASS InformationClass,
 283     OUT PVOID *Buffer)
 284 {
 285     FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
 286
 287     if(!Buffer) return FALSE;
 288     switch (InformationClass)
 289     {
 290         case PolicyAuditEventsInformation: /* 2 */
 291         {
 292             PPOLICY_AUDIT_EVENTS_INFO p = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 293                                                     sizeof(POLICY_AUDIT_EVENTS_INFO));
 294             p->AuditingMode = FALSE; /* no auditing */
 295             *Buffer = p;
 296         }
 297         break;
 298         case PolicyPrimaryDomainInformation: /* 3 */
 299         case PolicyAccountDomainInformation: /* 5 */
 300         {
 301             struct di
 302             {
 303                 POLICY_PRIMARY_DOMAIN_INFO ppdi;
 304                 SID sid;
 305             };
 306
 307             SID_IDENTIFIER_AUTHORITY localSidAuthority = {SECURITY_NT_AUTHORITY};
 308
 309             struct di * xdi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(xdi));
 310             HKEY key;
 311             BOOL useDefault = TRUE;
 312             LONG ret;
 313
 314             if ((ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
 315                  "System\\CurrentControlSet\\Services\\VxD\\VNETSUP", 0,
 316                  KEY_READ, &key)) == ERROR_SUCCESS)
 317             {
 318                 DWORD size = 0;
 319                 static const WCHAR wg[] = { 'W','o','r','k','g','r','o','u','p',0 };
 320
 321                 ret = RegQueryValueExW(key, wg, NULL, NULL, NULL, &size);
 322                 if (ret == ERROR_MORE_DATA || ret == ERROR_SUCCESS)
 323                 {
 324                     xdi->ppdi.Name.Buffer = HeapAlloc(GetProcessHeap(),
 325                                                       HEAP_ZERO_MEMORY, size);
 326
 327                     if ((ret = RegQueryValueExW(key, wg, NULL, NULL,
 328                          (LPBYTE)xdi->ppdi.Name.Buffer, &size)) == ERROR_SUCCESS)
 329                     {
 330                         xdi->ppdi.Name.Length = (USHORT)size;
 331                         useDefault = FALSE;
 332                     }
 333                     else
 334                     {
 335                         HeapFree(GetProcessHeap(), 0, xdi->ppdi.Name.Buffer);
 336                         xdi->ppdi.Name.Buffer = NULL;
 337                     }
 338                 }
 339                 RegCloseKey(key);
 340             }
 341             if (useDefault)
 342                 RtlCreateUnicodeStringFromAsciiz(&(xdi->ppdi.Name), "DOMAIN");
 343
 344             TRACE("setting domain to %s\n", debugstr_w(xdi->ppdi.Name.Buffer));
 345
 346             xdi->ppdi.Sid = &(xdi->sid);
 347             xdi->sid.Revision = SID_REVISION;
 348             xdi->sid.SubAuthorityCount = 1;
 349             xdi->sid.IdentifierAuthority = localSidAuthority;
 350             xdi->sid.SubAuthority[0] = SECURITY_LOCAL_SYSTEM_RID;
 351             *Buffer = xdi;
 352         }
 353         break;
 354         case  PolicyAuditLogInformation:
 355         case  PolicyPdAccountInformation:
 356         case  PolicyLsaServerRoleInformation:
 357         case  PolicyReplicaSourceInformation:
 358         case  PolicyDefaultQuotaInformation:
 359         case  PolicyModificationInformation:
 360         case  PolicyAuditFullSetInformation:
 361         case  PolicyAuditFullQueryInformation:
 362         case  PolicyDnsDomainInformation:
 363         {
 364             FIXME("category not implemented\n");
 365             return FALSE;
 366         }
 367     }
 368     return TRUE;
 369 }
 370
 371 /******************************************************************************
 372  * LsaRetrievePrivateData [ADVAPI32.@]
 373  *
 374  * Retrieves data stored by LsaStorePrivateData.
 375  *
 376  * PARAMS
 377  *  PolicyHandle [I] Handle to a Policy object.
 378  *  KeyName      [I] Name of the key where the data is stored.
 379  *  PrivateData  [O] Pointer to the private data.
 380  *
 381  * RETURNS
 382  *  Success: STATUS_SUCCESS.
 383  *  Failure: STATUS_OBJECT_NAME_NOT_FOUND or NTSTATUS code.
 384  */
 385 NTSTATUS WINAPI LsaRetrievePrivateData(
 386     IN LSA_HANDLE PolicyHandle,
 387     IN PLSA_UNICODE_STRING KeyName,
 388     OUT PLSA_UNICODE_STRING* PrivateData)
 389 {
 390     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 391     return STATUS_OBJECT_NAME_NOT_FOUND;
 392 }
 393
 394 /******************************************************************************
 395  * LsaSetInformationPolicy [ADVAPI32.@]
 396  *
 397  * Modifies information in a Policy object.
 398  *
 399  * PARAMS
 400  *  PolicyHandle     [I] Handle to a Policy object.
 401  *  InformationClass [I] Type of information to set.
 402  *  Buffer           [I] Pointer to the information to set.
 403  *
 404  * RETURNS
 405  *  Success: STATUS_SUCCESS.
 406  *  Failure: NTSTATUS code.
 407  */
 408 NTSTATUS WINAPI LsaSetInformationPolicy(
 409     IN LSA_HANDLE PolicyHandle,
 410     IN POLICY_INFORMATION_CLASS InformationClass,
 411     IN PVOID Buffer)
 412 {
 413     FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
 414
 415     return STATUS_UNSUCCESSFUL;
 416 }
 417
 418 /******************************************************************************
 419  * LsaStorePrivateData [ADVAPI32.@]
 420  *
 421  * Stores or deletes a Policy object's data under the specified reg key.
 422  *
 423  * PARAMS
 424  *  PolicyHandle [I] Handle to a Policy object.
 425  *  KeyName      [I] Name of the key where the data will be stored.
 426  *  PrivateData  [O] Pointer to the private data.
 427  *
 428  * RETURNS
 429  *  Success: STATUS_SUCCESS.
 430  *  Failure: STATUS_OBJECT_NAME_NOT_FOUND or NTSTATUS code.
 431  */
 432 NTSTATUS WINAPI LsaStorePrivateData(
 433     IN LSA_HANDLE PolicyHandle,
 434     IN PLSA_UNICODE_STRING KeyName,
 435     IN PLSA_UNICODE_STRING PrivateData)
 436 {
 437     FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
 438     return STATUS_OBJECT_NAME_NOT_FOUND;
 439 }