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(PLSA_DB_OBJECT PolicyObject,
  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", PolicyObject, 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(PolicyObject,
  43                                     L"PolPrDmN",
  44                                     Buffer,
  45                                     Length);
  46
  47     RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
  48
  49     if (!NT_SUCCESS(Status))
  50         return Status;
  51
  52     Length = 0;
  53     if (Info->Sid != NULL)
  54         Length = RtlLengthSid(Info->Sid);
  55
  56     Status = LsapSetObjectAttribute(PolicyObject,
  57                                     L"PolPrDmS",
  58                                     (LPBYTE)Info->Sid,
  59                                     Length);
  60
  61     return Status;
  62 }
  63
  64
  65 NTSTATUS
  66 LsarSetAccountDomain(PLSA_DB_OBJECT PolicyObject,
  67                      PLSAPR_POLICY_ACCOUNT_DOM_INFO Info)
  68 {
  69     PUNICODE_STRING Buffer;
  70     ULONG Length = 0;
  71     NTSTATUS Status;
  72     LPWSTR Ptr;
  73
  74     TRACE("LsarSetAccountDomain(%p, %p)\n", PolicyObject, Info);
  75
  76     Length = sizeof(UNICODE_STRING) + Info->DomainName.MaximumLength;
  77     Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
  78                              0,
  79                              Length);
  80     if (Buffer == NULL)
  81         return STATUS_INSUFFICIENT_RESOURCES;
  82
  83     Buffer->Length = Info->DomainName.Length;
  84     Buffer->MaximumLength = Info->DomainName.MaximumLength;
  85     Buffer->Buffer = (LPWSTR)sizeof(UNICODE_STRING);
  86     Ptr = (LPWSTR)((ULONG_PTR)Buffer + sizeof(UNICODE_STRING));
  87     memcpy(Ptr, Info->DomainName.Buffer, Info->DomainName.MaximumLength);
  88
  89     Status = LsapSetObjectAttribute(PolicyObject,
  90                                     L"PolAcDmN",
  91                                     Buffer,
  92                                     Length);
  93
  94     RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
  95
  96     if (!NT_SUCCESS(Status))
  97         return Status;
  98
  99     Length = 0;
 100     if (Info->Sid != NULL)
 101         Length = RtlLengthSid(Info->Sid);
 102
 103     Status = LsapSetObjectAttribute(PolicyObject,
 104                                     L"PolAcDmS",
 105                                     (LPBYTE)Info->Sid,
 106                                     Length);
 107
 108     return Status;
 109 }
 110
 111
 112 NTSTATUS
 113 LsarSetDnsDomain(PLSA_DB_OBJECT PolicyObject,
 114                  PLSAPR_POLICY_DNS_DOMAIN_INFO Info)
 115 {
 116
 117     return STATUS_NOT_IMPLEMENTED;
 118 }
 119
 120
 121 NTSTATUS
 122 LsarQueryAuditEvents(PLSA_DB_OBJECT PolicyObject,
 123                      PLSAPR_POLICY_INFORMATION *PolicyInformation)
 124 {
 125     PLSAPR_POLICY_AUDIT_EVENTS_INFO p = NULL;
 126
 127     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_AUDIT_EVENTS_INFO));
 128     if (p == NULL)
 129         return STATUS_INSUFFICIENT_RESOURCES;
 130
 131     p->AuditingMode = FALSE; /* no auditing */
 132     p->EventAuditingOptions = NULL;
 133     p->MaximumAuditEventCount = 0;
 134
 135     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 136
 137     return STATUS_SUCCESS;
 138 }
 139
 140
 141 NTSTATUS
 142 LsarQueryPrimaryDomain(PLSA_DB_OBJECT PolicyObject,
 143                        PLSAPR_POLICY_INFORMATION *PolicyInformation)
 144 {
 145     PLSAPR_POLICY_PRIMARY_DOM_INFO p = NULL;
 146     PUNICODE_STRING DomainName;
 147     ULONG AttributeSize;
 148     NTSTATUS Status;
 149
 150     *PolicyInformation = NULL;
 151
 152     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_PRIMARY_DOM_INFO));
 153     if (p == NULL)
 154         return STATUS_INSUFFICIENT_RESOURCES;
 155
 156     /* Domain Name */
 157     AttributeSize = 0;
 158     Status = LsapGetObjectAttribute(PolicyObject,
 159                                     L"PolPrDmN",
 160                                     NULL,
 161                                     &AttributeSize);
 162     if (!NT_SUCCESS(Status))
 163     {
 164         goto Done;
 165     }
 166
 167     if (AttributeSize > 0)
 168     {
 169         DomainName = MIDL_user_allocate(AttributeSize);
 170         if (DomainName == NULL)
 171         {
 172             Status = STATUS_INSUFFICIENT_RESOURCES;
 173             goto Done;
 174         }
 175
 176         Status = LsapGetObjectAttribute(PolicyObject,
 177                                         L"PolPrDmN",
 178                                         DomainName,
 179                                         &AttributeSize);
 180         if (Status == STATUS_SUCCESS)
 181         {
 182             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 183
 184             TRACE("PrimaryDomainName: %wZ\n", DomainName);
 185
 186             p->Name.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 187             if (p->Name.Buffer == NULL)
 188             {
 189                 MIDL_user_free(DomainName);
 190                 Status = STATUS_INSUFFICIENT_RESOURCES;
 191                 goto Done;
 192             }
 193
 194             p->Name.Length = DomainName->Length;
 195             p->Name.MaximumLength = DomainName->MaximumLength;
 196             memcpy(p->Name.Buffer,
 197                    DomainName->Buffer,
 198                    DomainName->MaximumLength);
 199         }
 200
 201         MIDL_user_free(DomainName);
 202     }
 203
 204     /* Domain SID */
 205     AttributeSize = 0;
 206     Status = LsapGetObjectAttribute(PolicyObject,
 207                                     L"PolPrDmS",
 208                                     NULL,
 209                                     &AttributeSize);
 210     if (!NT_SUCCESS(Status))
 211     {
 212         goto Done;
 213     }
 214
 215     if (AttributeSize > 0)
 216     {
 217         p->Sid = MIDL_user_allocate(AttributeSize);
 218         if (p->Sid == NULL)
 219         {
 220             Status = STATUS_INSUFFICIENT_RESOURCES;
 221             goto Done;
 222         }
 223
 224         Status = LsapGetObjectAttribute(PolicyObject,
 225                                         L"PolPrDmS",
 226                                         p->Sid,
 227                                         &AttributeSize);
 228     }
 229
 230     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 231
 232 Done:
 233     if (!NT_SUCCESS(Status))
 234     {
 235         if (p)
 236         {
 237             if (p->Name.Buffer)
 238                 MIDL_user_free(p->Name.Buffer);
 239
 240             if (p->Sid)
 241                 MIDL_user_free(p->Sid);
 242
 243             MIDL_user_free(p);
 244         }
 245     }
 246
 247     return Status;
 248 }
 249
 250
 251 NTSTATUS
 252 LsarQueryAccountDomain(PLSA_DB_OBJECT PolicyObject,
 253                        PLSAPR_POLICY_INFORMATION *PolicyInformation)
 254 {
 255     PLSAPR_POLICY_ACCOUNT_DOM_INFO p = NULL;
 256     PUNICODE_STRING DomainName;
 257     ULONG AttributeSize = 0;
 258     NTSTATUS Status;
 259
 260     *PolicyInformation = NULL;
 261
 262     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_ACCOUNT_DOM_INFO));
 263     if (p == NULL)
 264         return STATUS_INSUFFICIENT_RESOURCES;
 265
 266     /* Domain Name */
 267     Status = LsapGetObjectAttribute(PolicyObject,
 268                                     L"PolAcDmN",
 269                                     NULL,
 270                                     &AttributeSize);
 271     if (!NT_SUCCESS(Status))
 272     {
 273         goto Done;
 274     }
 275
 276     if (AttributeSize > 0)
 277     {
 278         DomainName = MIDL_user_allocate(AttributeSize);
 279         if (DomainName == NULL)
 280         {
 281             Status = STATUS_INSUFFICIENT_RESOURCES;
 282             goto Done;
 283         }
 284
 285         Status = LsapGetObjectAttribute(PolicyObject,
 286                                         L"PolAcDmN",
 287                                         DomainName,
 288                                         &AttributeSize);
 289         if (Status == STATUS_SUCCESS)
 290         {
 291             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 292
 293             TRACE("AccountDomainName: %wZ\n", DomainName);
 294
 295             p->DomainName.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 296             if (p->DomainName.Buffer == NULL)
 297             {
 298                 MIDL_user_free(DomainName);
 299                 Status = STATUS_INSUFFICIENT_RESOURCES;
 300                 goto Done;
 301             }
 302
 303             p->DomainName.Length = DomainName->Length;
 304             p->DomainName.MaximumLength = DomainName->MaximumLength;
 305             memcpy(p->DomainName.Buffer,
 306                    DomainName->Buffer,
 307                    DomainName->MaximumLength);
 308         }
 309
 310         MIDL_user_free(DomainName);
 311     }
 312
 313     /* Domain SID */
 314     AttributeSize = 0;
 315     Status = LsapGetObjectAttribute(PolicyObject,
 316                                     L"PolAcDmS",
 317                                     NULL,
 318                                     &AttributeSize);
 319     if (!NT_SUCCESS(Status))
 320     {
 321         goto Done;
 322     }
 323
 324     if (AttributeSize > 0)
 325     {
 326         p->Sid = MIDL_user_allocate(AttributeSize);
 327         if (p->Sid == NULL)
 328         {
 329             Status = STATUS_INSUFFICIENT_RESOURCES;
 330             goto Done;
 331         }
 332
 333         Status = LsapGetObjectAttribute(PolicyObject,
 334                                         L"PolAcDmS",
 335                                         p->Sid,
 336                                         &AttributeSize);
 337     }
 338
 339     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 340
 341 Done:
 342     if (!NT_SUCCESS(Status))
 343     {
 344         if (p)
 345         {
 346             if (p->DomainName.Buffer)
 347                 MIDL_user_free(p->DomainName.Buffer);
 348
 349             if (p->Sid)
 350                 MIDL_user_free(p->Sid);
 351
 352             MIDL_user_free(p);
 353         }
 354     }
 355
 356     return Status;
 357 }
 358
 359
 360 NTSTATUS
 361 LsarQueryDefaultQuota(PLSA_DB_OBJECT PolicyObject,
 362                       PLSAPR_POLICY_INFORMATION *PolicyInformation)
 363 {
 364     PPOLICY_DEFAULT_QUOTA_INFO QuotaInfo = NULL;
 365     ULONG AttributeSize;
 366     NTSTATUS Status;
 367
 368     *PolicyInformation = NULL;
 369
 370     AttributeSize = sizeof(POLICY_DEFAULT_QUOTA_INFO);
 371     QuotaInfo = MIDL_user_allocate(AttributeSize);
 372     if (QuotaInfo == NULL)
 373         return STATUS_INSUFFICIENT_RESOURCES;
 374
 375     Status = LsapGetObjectAttribute(PolicyObject,
 376                                     L"DefQuota",
 377                                     QuotaInfo,
 378                                     &AttributeSize);
 379     if (!NT_SUCCESS(Status))
 380     {
 381         MIDL_user_free(QuotaInfo);
 382     }
 383     else
 384     {
 385         *PolicyInformation = (PLSAPR_POLICY_INFORMATION)QuotaInfo;
 386     }
 387
 388     return Status;
 389 }
 390
 391
 392 NTSTATUS
 393 LsarQueryDnsDomain(PLSA_DB_OBJECT PolicyObject,
 394                    PLSAPR_POLICY_INFORMATION *PolicyInformation)
 395 {
 396     PLSAPR_POLICY_DNS_DOMAIN_INFO p = NULL;
 397
 398     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_DNS_DOMAIN_INFO));
 399     if (p == NULL)
 400         return STATUS_INSUFFICIENT_RESOURCES;
 401
 402     p->Name.Length = 0;
 403     p->Name.MaximumLength = 0;
 404     p->Name.Buffer = NULL;
 405 #if 0
 406             p->Name.Length = wcslen(L"COMPUTERNAME");
 407             p->Name.MaximumLength = p->Name.Length + sizeof(WCHAR);
 408             p->Name.Buffer = MIDL_user_allocate(p->Name.MaximumLength);
 409             if (p->Name.Buffer == NULL)
 410             {
 411                 MIDL_user_free(p);
 412                 return STATUS_INSUFFICIENT_RESOURCES;
 413             }
 414
 415             wcscpy(p->Name.Buffer, L"COMPUTERNAME");
 416 #endif
 417
 418     p->DnsDomainName.Length = 0;
 419     p->DnsDomainName.MaximumLength = 0;
 420     p->DnsDomainName.Buffer = NULL;
 421
 422     p->DnsForestName.Length = 0;
 423     p->DnsForestName.MaximumLength = 0;
 424     p->DnsForestName.Buffer = 0;
 425
 426     memset(&p->DomainGuid, 0, sizeof(GUID));
 427
 428     p->Sid = NULL; /* no domain, no workgroup */
 429
 430     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 431
 432     return STATUS_SUCCESS;
 433 }
 434
 435 /* EOF */