reactos/dll/win32/lsasrv/policy.c

   1 /*
   2  * PROJECT:     Local Security Authority Server DLL
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        dll/win32/lsasrv/policy.c
   5  * PURPOSE:     Policy object routines
   6  * COPYRIGHT:   Copyright 2011 Eric Kohl
   7  */
   8
   9 /* INCLUDES ****************************************************************/
  10
  11 #include "lsasrv.h"
  12
  13 WINE_DEFAULT_DEBUG_CHANNEL(lsasrv);
  14
  15
  16 /* FUNCTIONS ***************************************************************/
  17
  18 NTSTATUS
  19 LsarSetPrimaryDomain(LSAPR_HANDLE PolicyHandle,
  20                      PLSAPR_POLICY_PRIMARY_DOM_INFO Info)
  21 {
  22     PUNICODE_STRING Buffer;
  23     ULONG Length = 0;
  24     NTSTATUS Status;
  25     LPWSTR Ptr;
  26
  27     TRACE("LsarSetPrimaryDomain(%p, %p)\n", PolicyHandle, Info);
  28
  29     Length = sizeof(UNICODE_STRING) + Info->Name.MaximumLength;
  30     Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
  31                              0,
  32                              Length);
  33     if (Buffer == NULL)
  34         return STATUS_INSUFFICIENT_RESOURCES;
  35
  36     Buffer->Length = Info->Name.Length;
  37     Buffer->MaximumLength = Info->Name.MaximumLength;
  38     Buffer->Buffer = (LPWSTR)sizeof(UNICODE_STRING);
  39     Ptr = (LPWSTR)((ULONG_PTR)Buffer + sizeof(UNICODE_STRING));
  40     memcpy(Ptr, Info->Name.Buffer, Info->Name.MaximumLength);
  41
  42     Status = LsapSetObjectAttribute((PLSA_DB_OBJECT)PolicyHandle,
  43                                     L"PolPrDmN",
  44                                     Buffer, Length);
  45
  46     RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
  47
  48     if (!NT_SUCCESS(Status))
  49         return Status;
  50
  51     Length = 0;
  52     if (Info->Sid != NULL)
  53         Length = RtlLengthSid(Info->Sid);
  54
  55     Status = LsapSetObjectAttribute((PLSA_DB_OBJECT)PolicyHandle,
  56                                     L"PolPrDmS",
  57                                     (LPBYTE)Info->Sid,
  58                                     Length);
  59
  60     return Status;
  61 }
  62
  63
  64 NTSTATUS
  65 LsarSetAccountDomain(LSAPR_HANDLE PolicyHandle,
  66                      PLSAPR_POLICY_ACCOUNT_DOM_INFO Info)
  67 {
  68     PUNICODE_STRING Buffer;
  69     ULONG Length = 0;
  70     NTSTATUS Status;
  71     LPWSTR Ptr;
  72
  73     TRACE("LsarSetAccountDomain(%p, %p)\n", PolicyHandle, Info);
  74
  75     Length = sizeof(UNICODE_STRING) + Info->DomainName.MaximumLength;
  76     Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
  77                              0,
  78                              Length);
  79     if (Buffer == NULL)
  80         return STATUS_INSUFFICIENT_RESOURCES;
  81
  82     Buffer->Length = Info->DomainName.Length;
  83     Buffer->MaximumLength = Info->DomainName.MaximumLength;
  84     Buffer->Buffer = (LPWSTR)sizeof(UNICODE_STRING);
  85     Ptr = (LPWSTR)((ULONG_PTR)Buffer + sizeof(UNICODE_STRING));
  86     memcpy(Ptr, Info->DomainName.Buffer, Info->DomainName.MaximumLength);
  87
  88     Status = LsapSetObjectAttribute((PLSA_DB_OBJECT)PolicyHandle,
  89                                     L"PolAcDmN",
  90                                     Buffer, Length);
  91
  92     RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
  93
  94     if (!NT_SUCCESS(Status))
  95         return Status;
  96
  97     Length = 0;
  98     if (Info->Sid != NULL)
  99         Length = RtlLengthSid(Info->Sid);
 100
 101     Status = LsapSetObjectAttribute((PLSA_DB_OBJECT)PolicyHandle,
 102                                     L"PolAcDmS",
 103                                     (LPBYTE)Info->Sid,
 104                                     Length);
 105
 106     return Status;
 107 }
 108
 109
 110 NTSTATUS
 111 LsarSetDnsDomain(LSAPR_HANDLE PolicyHandle,
 112                  PLSAPR_POLICY_DNS_DOMAIN_INFO Info)
 113 {
 114
 115     return STATUS_NOT_IMPLEMENTED;
 116 }
 117
 118
 119 NTSTATUS
 120 LsarQueryAuditEvents(LSAPR_HANDLE PolicyHandle,
 121                      PLSAPR_POLICY_INFORMATION *PolicyInformation)
 122 {
 123     PLSAPR_POLICY_AUDIT_EVENTS_INFO p = NULL;
 124
 125     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_AUDIT_EVENTS_INFO));
 126     if (p == NULL)
 127         return STATUS_INSUFFICIENT_RESOURCES;
 128
 129     p->AuditingMode = FALSE; /* no auditing */
 130     p->EventAuditingOptions = NULL;
 131     p->MaximumAuditEventCount = 0;
 132
 133     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 134
 135     return STATUS_SUCCESS;
 136 }
 137
 138
 139 NTSTATUS
 140 LsarQueryPrimaryDomain(LSAPR_HANDLE PolicyHandle,
 141                        PLSAPR_POLICY_INFORMATION *PolicyInformation)
 142 {
 143     PLSAPR_POLICY_PRIMARY_DOM_INFO p = NULL;
 144     PUNICODE_STRING DomainName;
 145     ULONG AttributeSize;
 146     NTSTATUS Status;
 147
 148     *PolicyInformation = NULL;
 149
 150     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_PRIMARY_DOM_INFO));
 151     if (p == NULL)
 152         return STATUS_INSUFFICIENT_RESOURCES;
 153
 154     /* Domain Name */
 155     Status = LsapGetObjectAttribute((PLSA_DB_OBJECT)PolicyHandle,
 156                                     L"PolPrDmN",
 157                                     NULL,
 158                                     &AttributeSize);
 159     if (!NT_SUCCESS(Status))
 160     {
 161         goto Done;
 162     }
 163
 164     if (AttributeSize > 0)
 165     {
 166         DomainName = MIDL_user_allocate(AttributeSize);
 167         if (DomainName == NULL)
 168         {
 169             Status = STATUS_INSUFFICIENT_RESOURCES;
 170             goto Done;
 171         }
 172
 173         Status = LsapGetObjectAttribute((PLSA_DB_OBJECT)PolicyHandle,
 174                                         L"PolPrDmN",
 175                                         DomainName,
 176                                         &AttributeSize);
 177         if (Status == STATUS_SUCCESS)
 178         {
 179             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 180
 181             TRACE("PrimaryDomainName: %wZ\n", DomainName);
 182
 183             p->Name.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 184             if (p->Name.Buffer == NULL)
 185             {
 186                 MIDL_user_free(DomainName);
 187                 Status = STATUS_INSUFFICIENT_RESOURCES;
 188                 goto Done;
 189             }
 190
 191             p->Name.Length = DomainName->Length;
 192             p->Name.MaximumLength = DomainName->MaximumLength;
 193             memcpy(p->Name.Buffer,
 194                    DomainName->Buffer,
 195                    DomainName->MaximumLength);
 196         }
 197
 198         MIDL_user_free(DomainName);
 199     }
 200
 201     /* Domain SID */
 202     AttributeSize = 0;
 203     Status = LsapGetObjectAttribute((PLSA_DB_OBJECT)PolicyHandle,
 204                                     L"PolPrDmS",
 205                                     NULL,
 206                                     &AttributeSize);
 207     if (!NT_SUCCESS(Status))
 208     {
 209         goto Done;
 210     }
 211
 212     if (AttributeSize > 0)
 213     {
 214         p->Sid = MIDL_user_allocate(AttributeSize);
 215         if (p->Sid == NULL)
 216         {
 217             Status = STATUS_INSUFFICIENT_RESOURCES;
 218             goto Done;
 219         }
 220
 221         Status = LsapGetObjectAttribute((PLSA_DB_OBJECT)PolicyHandle,
 222                                         L"PolPrDmS",
 223                                         p->Sid,
 224                                         &AttributeSize);
 225     }
 226
 227     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 228
 229 Done:
 230     if (!NT_SUCCESS(Status))
 231     {
 232         if (p)
 233         {
 234             if (p->Name.Buffer)
 235                 MIDL_user_free(p->Name.Buffer);
 236
 237             if (p->Sid)
 238                 MIDL_user_free(p->Sid);
 239
 240             MIDL_user_free(p);
 241         }
 242     }
 243
 244     return STATUS_SUCCESS;
 245 }
 246
 247
 248 NTSTATUS
 249 LsarQueryAccountDomain(LSAPR_HANDLE PolicyHandle,
 250                        PLSAPR_POLICY_INFORMATION *PolicyInformation)
 251 {
 252     PLSAPR_POLICY_ACCOUNT_DOM_INFO p = NULL;
 253     PUNICODE_STRING DomainName;
 254     ULONG AttributeSize;
 255     NTSTATUS Status;
 256
 257     *PolicyInformation = NULL;
 258
 259     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_ACCOUNT_DOM_INFO));
 260     if (p == NULL)
 261         return STATUS_INSUFFICIENT_RESOURCES;
 262
 263     /* Domain Name */
 264     Status = LsapGetObjectAttribute((PLSA_DB_OBJECT)PolicyHandle,
 265                                     L"PolAcDmN",
 266                                     NULL,
 267                                     &AttributeSize);
 268     if (!NT_SUCCESS(Status))
 269     {
 270         goto Done;
 271     }
 272
 273     if (AttributeSize > 0)
 274     {
 275         DomainName = MIDL_user_allocate(AttributeSize);
 276         if (DomainName == NULL)
 277         {
 278             Status = STATUS_INSUFFICIENT_RESOURCES;
 279             goto Done;
 280         }
 281
 282         Status = LsapGetObjectAttribute((PLSA_DB_OBJECT)PolicyHandle,
 283                                         L"PolAcDmN",
 284                                         DomainName,
 285                                         &AttributeSize);
 286         if (Status == STATUS_SUCCESS)
 287         {
 288             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 289
 290             TRACE("AccountDomainName: %wZ\n", DomainName);
 291
 292             p->DomainName.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 293             if (p->DomainName.Buffer == NULL)
 294             {
 295                 MIDL_user_free(DomainName);
 296                 Status = STATUS_INSUFFICIENT_RESOURCES;
 297                 goto Done;
 298             }
 299
 300             p->DomainName.Length = DomainName->Length;
 301             p->DomainName.MaximumLength = DomainName->MaximumLength;
 302             memcpy(p->DomainName.Buffer,
 303                    DomainName->Buffer,
 304                    DomainName->MaximumLength);
 305         }
 306
 307         MIDL_user_free(DomainName);
 308     }
 309
 310     /* Domain SID */
 311     AttributeSize = 0;
 312     Status = LsapGetObjectAttribute((PLSA_DB_OBJECT)PolicyHandle,
 313                                     L"PolAcDmS",
 314                                     NULL,
 315                                     &AttributeSize);
 316     if (!NT_SUCCESS(Status))
 317     {
 318         goto Done;
 319     }
 320
 321     if (AttributeSize > 0)
 322     {
 323         p->Sid = MIDL_user_allocate(AttributeSize);
 324         if (p->Sid == NULL)
 325         {
 326             Status = STATUS_INSUFFICIENT_RESOURCES;
 327             goto Done;
 328         }
 329
 330         Status = LsapGetObjectAttribute((PLSA_DB_OBJECT)PolicyHandle,
 331                                         L"PolAcDmS",
 332                                         p->Sid,
 333                                         &AttributeSize);
 334     }
 335
 336     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 337
 338 Done:
 339     if (!NT_SUCCESS(Status))
 340     {
 341         if (p)
 342         {
 343             if (p->DomainName.Buffer)
 344                 MIDL_user_free(p->DomainName.Buffer);
 345
 346             if (p->Sid)
 347                 MIDL_user_free(p->Sid);
 348
 349             MIDL_user_free(p);
 350         }
 351     }
 352
 353     return STATUS_SUCCESS;
 354 }
 355
 356
 357 NTSTATUS
 358 LsarQueryDnsDomain(LSAPR_HANDLE PolicyHandle,
 359                    PLSAPR_POLICY_INFORMATION *PolicyInformation)
 360 {
 361     PLSAPR_POLICY_DNS_DOMAIN_INFO p = NULL;
 362
 363     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_DNS_DOMAIN_INFO));
 364     if (p == NULL)
 365         return STATUS_INSUFFICIENT_RESOURCES;
 366
 367     p->Name.Length = 0;
 368     p->Name.MaximumLength = 0;
 369     p->Name.Buffer = NULL;
 370 #if 0
 371             p->Name.Length = wcslen(L"COMPUTERNAME");
 372             p->Name.MaximumLength = p->Name.Length + sizeof(WCHAR);
 373             p->Name.Buffer = MIDL_user_allocate(p->Name.MaximumLength);
 374             if (p->Name.Buffer == NULL)
 375             {
 376                 MIDL_user_free(p);
 377                 return STATUS_INSUFFICIENT_RESOURCES;
 378             }
 379
 380             wcscpy(p->Name.Buffer, L"COMPUTERNAME");
 381 #endif
 382
 383     p->DnsDomainName.Length = 0;
 384     p->DnsDomainName.MaximumLength = 0;
 385     p->DnsDomainName.Buffer = NULL;
 386
 387     p->DnsForestName.Length = 0;
 388     p->DnsForestName.MaximumLength = 0;
 389     p->DnsForestName.Buffer = 0;
 390
 391     memset(&p->DomainGuid, 0, sizeof(GUID));
 392
 393     p->Sid = NULL; /* no domain, no workgroup */
 394
 395     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 396
 397     return STATUS_SUCCESS;
 398 }
 399
 400 /* EOF */