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 LsarQueryAuditLog(PLSA_DB_OBJECT PolicyObject,
 123                   PLSAPR_POLICY_INFORMATION *PolicyInformation)
 124 {
 125     PPOLICY_AUDIT_LOG_INFO AuditLogInfo = NULL;
 126     ULONG AttributeSize;
 127     NTSTATUS Status;
 128
 129     *PolicyInformation = NULL;
 130
 131     AttributeSize = sizeof(POLICY_AUDIT_LOG_INFO);
 132     AuditLogInfo = MIDL_user_allocate(AttributeSize);
 133     if (AuditLogInfo == NULL)
 134         return STATUS_INSUFFICIENT_RESOURCES;
 135
 136     Status = LsapGetObjectAttribute(PolicyObject,
 137                                     L"PolAdtLg",
 138                                     AuditLogInfo,
 139                                     &AttributeSize);
 140     if (!NT_SUCCESS(Status))
 141     {
 142         MIDL_user_free(AuditLogInfo);
 143     }
 144     else
 145     {
 146         *PolicyInformation = (PLSAPR_POLICY_INFORMATION)AuditLogInfo;
 147     }
 148
 149     return Status;
 150 }
 151
 152
 153 NTSTATUS
 154 LsarQueryAuditEvents(PLSA_DB_OBJECT PolicyObject,
 155                      PLSAPR_POLICY_INFORMATION *PolicyInformation)
 156 {
 157     PLSAP_POLICY_AUDIT_EVENTS_DATA AuditData = NULL;
 158     PLSAPR_POLICY_AUDIT_EVENTS_INFO p = NULL;
 159     ULONG AttributeSize;
 160     NTSTATUS Status = STATUS_SUCCESS;
 161
 162     *PolicyInformation = NULL;
 163
 164     AttributeSize = 0;
 165     Status = LsapGetObjectAttribute(PolicyObject,
 166                                     L"PolAdtEv",
 167                                     NULL,
 168                                     &AttributeSize);
 169     if (!NT_SUCCESS(Status))
 170         return Status;
 171
 172     if (AttributeSize > 0)
 173     {
 174         AuditData = MIDL_user_allocate(AttributeSize);
 175         if (AuditData == NULL)
 176             return STATUS_INSUFFICIENT_RESOURCES;
 177
 178         Status = LsapGetObjectAttribute(PolicyObject,
 179                                         L"PolAdtEv",
 180                                         AuditData,
 181                                         &AttributeSize);
 182         if (!NT_SUCCESS(Status))
 183             goto done;
 184
 185         p = MIDL_user_allocate(sizeof(LSAPR_POLICY_AUDIT_EVENTS_INFO));
 186         if (p == NULL)
 187         {
 188             Status = STATUS_INSUFFICIENT_RESOURCES;
 189             goto done;
 190         }
 191
 192         p->AuditingMode = AuditData->AuditingMode;
 193         p->MaximumAuditEventCount = AuditData->MaximumAuditEventCount;
 194
 195         p->EventAuditingOptions = MIDL_user_allocate(AuditData->MaximumAuditEventCount * sizeof(DWORD));
 196         if (p->EventAuditingOptions == NULL)
 197         {
 198             Status = STATUS_INSUFFICIENT_RESOURCES;
 199             goto done;
 200         }
 201
 202         memcpy(p->EventAuditingOptions,
 203                &(AuditData->AuditEvents[0]),
 204                AuditData->MaximumAuditEventCount * sizeof(DWORD));
 205     }
 206
 207     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 208
 209 done:
 210     if (!NT_SUCCESS(Status))
 211     {
 212         if (p->EventAuditingOptions != NULL)
 213             MIDL_user_free(p->EventAuditingOptions);
 214
 215         if (p != NULL)
 216             MIDL_user_free(p);
 217     }
 218
 219     if (AuditData != NULL)
 220         MIDL_user_free(AuditData);
 221
 222     return STATUS_SUCCESS;
 223 }
 224
 225
 226 NTSTATUS
 227 LsarQueryPrimaryDomain(PLSA_DB_OBJECT PolicyObject,
 228                        PLSAPR_POLICY_INFORMATION *PolicyInformation)
 229 {
 230     PLSAPR_POLICY_PRIMARY_DOM_INFO p = NULL;
 231     PUNICODE_STRING DomainName;
 232     ULONG AttributeSize;
 233     NTSTATUS Status;
 234
 235     *PolicyInformation = NULL;
 236
 237     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_PRIMARY_DOM_INFO));
 238     if (p == NULL)
 239         return STATUS_INSUFFICIENT_RESOURCES;
 240
 241     /* Domain Name */
 242     AttributeSize = 0;
 243     Status = LsapGetObjectAttribute(PolicyObject,
 244                                     L"PolPrDmN",
 245                                     NULL,
 246                                     &AttributeSize);
 247     if (!NT_SUCCESS(Status))
 248     {
 249         goto Done;
 250     }
 251
 252     if (AttributeSize > 0)
 253     {
 254         DomainName = MIDL_user_allocate(AttributeSize);
 255         if (DomainName == NULL)
 256         {
 257             Status = STATUS_INSUFFICIENT_RESOURCES;
 258             goto Done;
 259         }
 260
 261         Status = LsapGetObjectAttribute(PolicyObject,
 262                                         L"PolPrDmN",
 263                                         DomainName,
 264                                         &AttributeSize);
 265         if (Status == STATUS_SUCCESS)
 266         {
 267             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 268
 269             TRACE("PrimaryDomainName: %wZ\n", DomainName);
 270
 271             p->Name.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 272             if (p->Name.Buffer == NULL)
 273             {
 274                 MIDL_user_free(DomainName);
 275                 Status = STATUS_INSUFFICIENT_RESOURCES;
 276                 goto Done;
 277             }
 278
 279             p->Name.Length = DomainName->Length;
 280             p->Name.MaximumLength = DomainName->MaximumLength;
 281             memcpy(p->Name.Buffer,
 282                    DomainName->Buffer,
 283                    DomainName->MaximumLength);
 284         }
 285
 286         MIDL_user_free(DomainName);
 287     }
 288
 289     /* Domain SID */
 290     AttributeSize = 0;
 291     Status = LsapGetObjectAttribute(PolicyObject,
 292                                     L"PolPrDmS",
 293                                     NULL,
 294                                     &AttributeSize);
 295     if (!NT_SUCCESS(Status))
 296     {
 297         goto Done;
 298     }
 299
 300     if (AttributeSize > 0)
 301     {
 302         p->Sid = MIDL_user_allocate(AttributeSize);
 303         if (p->Sid == NULL)
 304         {
 305             Status = STATUS_INSUFFICIENT_RESOURCES;
 306             goto Done;
 307         }
 308
 309         Status = LsapGetObjectAttribute(PolicyObject,
 310                                         L"PolPrDmS",
 311                                         p->Sid,
 312                                         &AttributeSize);
 313     }
 314
 315     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 316
 317 Done:
 318     if (!NT_SUCCESS(Status))
 319     {
 320         if (p)
 321         {
 322             if (p->Name.Buffer)
 323                 MIDL_user_free(p->Name.Buffer);
 324
 325             if (p->Sid)
 326                 MIDL_user_free(p->Sid);
 327
 328             MIDL_user_free(p);
 329         }
 330     }
 331
 332     return Status;
 333 }
 334
 335
 336 NTSTATUS
 337 LsarQueryPdAccount(PLSA_DB_OBJECT PolicyObject,
 338                    PLSAPR_POLICY_INFORMATION *PolicyInformation)
 339 {
 340     PLSAPR_POLICY_PD_ACCOUNT_INFO PdAccountInfo = NULL;
 341
 342     *PolicyInformation = NULL;
 343
 344     PdAccountInfo = MIDL_user_allocate(sizeof(LSAPR_POLICY_PD_ACCOUNT_INFO));
 345     if (PdAccountInfo == NULL)
 346         return STATUS_INSUFFICIENT_RESOURCES;
 347
 348     PdAccountInfo->Name.Length = 0;
 349     PdAccountInfo->Name.MaximumLength = 0;
 350     PdAccountInfo->Name.Buffer = NULL;
 351
 352     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)PdAccountInfo;
 353
 354     return STATUS_SUCCESS;
 355 }
 356
 357
 358 NTSTATUS
 359 LsarQueryAccountDomain(PLSA_DB_OBJECT PolicyObject,
 360                        PLSAPR_POLICY_INFORMATION *PolicyInformation)
 361 {
 362     PLSAPR_POLICY_ACCOUNT_DOM_INFO p = NULL;
 363     PUNICODE_STRING DomainName;
 364     ULONG AttributeSize = 0;
 365     NTSTATUS Status;
 366
 367     *PolicyInformation = NULL;
 368
 369     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_ACCOUNT_DOM_INFO));
 370     if (p == NULL)
 371         return STATUS_INSUFFICIENT_RESOURCES;
 372
 373     /* Domain Name */
 374     Status = LsapGetObjectAttribute(PolicyObject,
 375                                     L"PolAcDmN",
 376                                     NULL,
 377                                     &AttributeSize);
 378     if (!NT_SUCCESS(Status))
 379     {
 380         goto Done;
 381     }
 382
 383     if (AttributeSize > 0)
 384     {
 385         DomainName = MIDL_user_allocate(AttributeSize);
 386         if (DomainName == NULL)
 387         {
 388             Status = STATUS_INSUFFICIENT_RESOURCES;
 389             goto Done;
 390         }
 391
 392         Status = LsapGetObjectAttribute(PolicyObject,
 393                                         L"PolAcDmN",
 394                                         DomainName,
 395                                         &AttributeSize);
 396         if (Status == STATUS_SUCCESS)
 397         {
 398             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 399
 400             TRACE("AccountDomainName: %wZ\n", DomainName);
 401
 402             p->DomainName.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 403             if (p->DomainName.Buffer == NULL)
 404             {
 405                 MIDL_user_free(DomainName);
 406                 Status = STATUS_INSUFFICIENT_RESOURCES;
 407                 goto Done;
 408             }
 409
 410             p->DomainName.Length = DomainName->Length;
 411             p->DomainName.MaximumLength = DomainName->MaximumLength;
 412             memcpy(p->DomainName.Buffer,
 413                    DomainName->Buffer,
 414                    DomainName->MaximumLength);
 415         }
 416
 417         MIDL_user_free(DomainName);
 418     }
 419
 420     /* Domain SID */
 421     AttributeSize = 0;
 422     Status = LsapGetObjectAttribute(PolicyObject,
 423                                     L"PolAcDmS",
 424                                     NULL,
 425                                     &AttributeSize);
 426     if (!NT_SUCCESS(Status))
 427     {
 428         goto Done;
 429     }
 430
 431     if (AttributeSize > 0)
 432     {
 433         p->Sid = MIDL_user_allocate(AttributeSize);
 434         if (p->Sid == NULL)
 435         {
 436             Status = STATUS_INSUFFICIENT_RESOURCES;
 437             goto Done;
 438         }
 439
 440         Status = LsapGetObjectAttribute(PolicyObject,
 441                                         L"PolAcDmS",
 442                                         p->Sid,
 443                                         &AttributeSize);
 444     }
 445
 446     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 447
 448 Done:
 449     if (!NT_SUCCESS(Status))
 450     {
 451         if (p)
 452         {
 453             if (p->DomainName.Buffer)
 454                 MIDL_user_free(p->DomainName.Buffer);
 455
 456             if (p->Sid)
 457                 MIDL_user_free(p->Sid);
 458
 459             MIDL_user_free(p);
 460         }
 461     }
 462
 463     return Status;
 464 }
 465
 466
 467 NTSTATUS
 468 LsarQueryServerRole(PLSA_DB_OBJECT PolicyObject,
 469                     PLSAPR_POLICY_INFORMATION *PolicyInformation)
 470 {
 471     PPOLICY_LSA_SERVER_ROLE_INFO ServerRoleInfo = NULL;
 472     ULONG AttributeSize;
 473     NTSTATUS Status;
 474
 475     *PolicyInformation = NULL;
 476
 477     AttributeSize = sizeof(POLICY_LSA_SERVER_ROLE_INFO);
 478     ServerRoleInfo = MIDL_user_allocate(AttributeSize);
 479     if (ServerRoleInfo == NULL)
 480         return STATUS_INSUFFICIENT_RESOURCES;
 481
 482     Status = LsapGetObjectAttribute(PolicyObject,
 483                                     L"PolSrvRo",
 484                                     ServerRoleInfo,
 485                                     &AttributeSize);
 486     if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
 487     {
 488         ServerRoleInfo->LsaServerRole = PolicyServerRolePrimary;
 489         Status = STATUS_SUCCESS;
 490     }
 491
 492     if (!NT_SUCCESS(Status))
 493     {
 494         MIDL_user_free(ServerRoleInfo);
 495     }
 496     else
 497     {
 498         *PolicyInformation = (PLSAPR_POLICY_INFORMATION)ServerRoleInfo;
 499     }
 500
 501     return Status;
 502 }
 503
 504
 505 NTSTATUS
 506 LsarQueryDefaultQuota(PLSA_DB_OBJECT PolicyObject,
 507                       PLSAPR_POLICY_INFORMATION *PolicyInformation)
 508 {
 509     PPOLICY_DEFAULT_QUOTA_INFO QuotaInfo = NULL;
 510     ULONG AttributeSize;
 511     NTSTATUS Status;
 512
 513     *PolicyInformation = NULL;
 514
 515     AttributeSize = sizeof(POLICY_DEFAULT_QUOTA_INFO);
 516     QuotaInfo = MIDL_user_allocate(AttributeSize);
 517     if (QuotaInfo == NULL)
 518         return STATUS_INSUFFICIENT_RESOURCES;
 519
 520     Status = LsapGetObjectAttribute(PolicyObject,
 521                                     L"DefQuota",
 522                                     QuotaInfo,
 523                                     &AttributeSize);
 524     if (!NT_SUCCESS(Status))
 525     {
 526         MIDL_user_free(QuotaInfo);
 527     }
 528     else
 529     {
 530         *PolicyInformation = (PLSAPR_POLICY_INFORMATION)QuotaInfo;
 531     }
 532
 533     return Status;
 534 }
 535
 536
 537 NTSTATUS
 538 LsarQueryReplicaSource(PLSA_DB_OBJECT PolicyObject,
 539                        PLSAPR_POLICY_INFORMATION *PolicyInformation)
 540 {
 541     *PolicyInformation = NULL;
 542     return STATUS_NOT_IMPLEMENTED;
 543 }
 544
 545
 546 NTSTATUS
 547 LsarQueryModification(PLSA_DB_OBJECT PolicyObject,
 548                       PLSAPR_POLICY_INFORMATION *PolicyInformation)
 549 {
 550     PPOLICY_MODIFICATION_INFO Info = NULL;
 551     ULONG AttributeSize;
 552     NTSTATUS Status;
 553
 554     *PolicyInformation = NULL;
 555
 556     AttributeSize = sizeof(POLICY_MODIFICATION_INFO);
 557     Info = MIDL_user_allocate(AttributeSize);
 558     if (Info == NULL)
 559         return STATUS_INSUFFICIENT_RESOURCES;
 560
 561     Status = LsapGetObjectAttribute(PolicyObject,
 562                                     L"PolMod",
 563                                     Info,
 564                                     &AttributeSize);
 565     if (!NT_SUCCESS(Status))
 566     {
 567         MIDL_user_free(Info);
 568     }
 569     else
 570     {
 571         *PolicyInformation = (PLSAPR_POLICY_INFORMATION)Info;
 572     }
 573
 574     return Status;
 575 }
 576
 577
 578 NTSTATUS
 579 LsarQueryAuditFull(PLSA_DB_OBJECT PolicyObject,
 580                    PLSAPR_POLICY_INFORMATION *PolicyInformation)
 581 {
 582     PPOLICY_AUDIT_FULL_QUERY_INFO AuditFullInfo = NULL;
 583     ULONG AttributeSize;
 584     NTSTATUS Status;
 585
 586     *PolicyInformation = NULL;
 587
 588     AttributeSize = sizeof(POLICY_AUDIT_FULL_QUERY_INFO);
 589     AuditFullInfo = MIDL_user_allocate(AttributeSize);
 590     if (AuditFullInfo == NULL)
 591         return STATUS_INSUFFICIENT_RESOURCES;
 592
 593     Status = LsapGetObjectAttribute(PolicyObject,
 594                                     L"PolAdtFl",
 595                                     AuditFullInfo,
 596                                     &AttributeSize);
 597     if (!NT_SUCCESS(Status))
 598     {
 599         MIDL_user_free(AuditFullInfo);
 600     }
 601     else
 602     {
 603         *PolicyInformation = (PLSAPR_POLICY_INFORMATION)AuditFullInfo;
 604     }
 605
 606     return Status;
 607 }
 608
 609
 610 NTSTATUS
 611 LsarQueryDnsDomain(PLSA_DB_OBJECT PolicyObject,
 612                    PLSAPR_POLICY_INFORMATION *PolicyInformation)
 613 {
 614     PLSAPR_POLICY_DNS_DOMAIN_INFO p = NULL;
 615     PUNICODE_STRING DomainName;
 616     ULONG AttributeSize;
 617     NTSTATUS Status;
 618
 619     *PolicyInformation = NULL;
 620
 621     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_DNS_DOMAIN_INFO));
 622     if (p == NULL)
 623         return STATUS_INSUFFICIENT_RESOURCES;
 624
 625     /* Primary Domain Name */
 626     AttributeSize = 0;
 627     Status = LsapGetObjectAttribute(PolicyObject,
 628                                     L"PolPrDmN",
 629                                     NULL,
 630                                     &AttributeSize);
 631     if (!NT_SUCCESS(Status))
 632     {
 633         goto done;
 634     }
 635
 636     if (AttributeSize > 0)
 637     {
 638         DomainName = MIDL_user_allocate(AttributeSize);
 639         if (DomainName == NULL)
 640         {
 641             Status = STATUS_INSUFFICIENT_RESOURCES;
 642             goto done;
 643         }
 644
 645         Status = LsapGetObjectAttribute(PolicyObject,
 646                                         L"PolPrDmN",
 647                                         DomainName,
 648                                         &AttributeSize);
 649         if (Status == STATUS_SUCCESS)
 650         {
 651             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 652
 653             TRACE("PrimaryDomainName: %wZ\n", DomainName);
 654
 655             p->Name.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 656             if (p->Name.Buffer == NULL)
 657             {
 658                 MIDL_user_free(DomainName);
 659                 Status = STATUS_INSUFFICIENT_RESOURCES;
 660                 goto done;
 661             }
 662
 663             p->Name.Length = DomainName->Length;
 664             p->Name.MaximumLength = DomainName->MaximumLength;
 665             memcpy(p->Name.Buffer,
 666                    DomainName->Buffer,
 667                    DomainName->MaximumLength);
 668         }
 669
 670         MIDL_user_free(DomainName);
 671     }
 672
 673     /* Primary Domain SID */
 674     AttributeSize = 0;
 675     Status = LsapGetObjectAttribute(PolicyObject,
 676                                     L"PolPrDmS",
 677                                     NULL,
 678                                     &AttributeSize);
 679     if (!NT_SUCCESS(Status))
 680     {
 681         goto done;
 682     }
 683
 684     if (AttributeSize > 0)
 685     {
 686         p->Sid = MIDL_user_allocate(AttributeSize);
 687         if (p->Sid == NULL)
 688         {
 689             Status = STATUS_INSUFFICIENT_RESOURCES;
 690             goto done;
 691         }
 692
 693         Status = LsapGetObjectAttribute(PolicyObject,
 694                                         L"PolPrDmS",
 695                                         p->Sid,
 696                                         &AttributeSize);
 697     }
 698
 699     /* DNS Domain Name */
 700     AttributeSize = 0;
 701     Status = LsapGetObjectAttribute(PolicyObject,
 702                                     L"PolDnDDN",
 703                                     NULL,
 704                                     &AttributeSize);
 705     if (!NT_SUCCESS(Status))
 706         goto done;
 707
 708     if (AttributeSize > 0)
 709     {
 710         DomainName = MIDL_user_allocate(AttributeSize);
 711         if (DomainName == NULL)
 712         {
 713             Status = STATUS_INSUFFICIENT_RESOURCES;
 714             goto done;
 715         }
 716
 717         Status = LsapGetObjectAttribute(PolicyObject,
 718                                         L"PolDnDDN",
 719                                         DomainName,
 720                                         &AttributeSize);
 721         if (Status == STATUS_SUCCESS)
 722         {
 723             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 724
 725             TRACE("DNS Domain Name: %wZ\n", DomainName);
 726
 727             p->DnsDomainName.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 728             if (p->DnsDomainName.Buffer == NULL)
 729             {
 730                 MIDL_user_free(DomainName);
 731                 Status = STATUS_INSUFFICIENT_RESOURCES;
 732                 goto done;
 733             }
 734
 735             p->DnsDomainName.Length = DomainName->Length;
 736             p->DnsDomainName.MaximumLength = DomainName->MaximumLength;
 737             memcpy(p->DnsDomainName.Buffer,
 738                    DomainName->Buffer,
 739                    DomainName->MaximumLength);
 740         }
 741
 742         MIDL_user_free(DomainName);
 743     }
 744
 745     /* DNS Forest Name */
 746     AttributeSize = 0;
 747     Status = LsapGetObjectAttribute(PolicyObject,
 748                                     L"PolDnTrN",
 749                                     NULL,
 750                                     &AttributeSize);
 751     if (!NT_SUCCESS(Status))
 752         goto done;
 753
 754     if (AttributeSize > 0)
 755     {
 756         DomainName = MIDL_user_allocate(AttributeSize);
 757         if (DomainName == NULL)
 758         {
 759             Status = STATUS_INSUFFICIENT_RESOURCES;
 760             goto done;
 761         }
 762
 763         Status = LsapGetObjectAttribute(PolicyObject,
 764                                         L"PolDnTrN",
 765                                         DomainName,
 766                                         &AttributeSize);
 767         if (Status == STATUS_SUCCESS)
 768         {
 769             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 770
 771             TRACE("DNS Forest Name: %wZ\n", DomainName);
 772
 773             p->DnsForestName.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 774             if (p->DnsForestName.Buffer == NULL)
 775             {
 776                 MIDL_user_free(DomainName);
 777                 Status = STATUS_INSUFFICIENT_RESOURCES;
 778                 goto done;
 779             }
 780
 781             p->DnsForestName.Length = DomainName->Length;
 782             p->DnsForestName.MaximumLength = DomainName->MaximumLength;
 783             memcpy(p->DnsForestName.Buffer,
 784                    DomainName->Buffer,
 785                    DomainName->MaximumLength);
 786         }
 787
 788         MIDL_user_free(DomainName);
 789     }
 790
 791     /* DNS Domain GUID */
 792     AttributeSize = sizeof(GUID);
 793     Status = LsapGetObjectAttribute(PolicyObject,
 794                                     L"PolDnDmG",
 795                                     &(p->DomainGuid),
 796                                     &AttributeSize);
 797     if (!NT_SUCCESS(Status))
 798         goto done;
 799
 800     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 801
 802 done:
 803     if (!NT_SUCCESS(Status))
 804     {
 805         if (p)
 806         {
 807             if (p->Name.Buffer)
 808                 MIDL_user_free(p->Name.Buffer);
 809
 810             if (p->DnsDomainName.Buffer)
 811                 MIDL_user_free(p->DnsDomainName.Buffer);
 812
 813             if (p->DnsForestName.Buffer)
 814                 MIDL_user_free(p->DnsForestName.Buffer);
 815
 816             if (p->Sid)
 817                 MIDL_user_free(p->Sid);
 818
 819             MIDL_user_free(p);
 820         }
 821     }
 822
 823     return Status;
 824 }
 825
 826
 827 NTSTATUS
 828 LsarQueryDnsDomainInt(PLSA_DB_OBJECT PolicyObject,
 829                       PLSAPR_POLICY_INFORMATION *PolicyInformation)
 830 {
 831     *PolicyInformation = NULL;
 832     return STATUS_NOT_IMPLEMENTED;
 833 }
 834
 835
 836 NTSTATUS
 837 LsarQueryLocalAccountDomain(PLSA_DB_OBJECT PolicyObject,
 838                             PLSAPR_POLICY_INFORMATION *PolicyInformation)
 839 {
 840     *PolicyInformation = NULL;
 841     return STATUS_NOT_IMPLEMENTED;
 842 }
 843
 844 /* EOF */