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 WINAPI
  20 LsaIOpenPolicyTrusted(OUT LSAPR_HANDLE *PolicyHandle)
  21 {
  22     PLSA_DB_OBJECT PolicyObject;
  23     NTSTATUS Status;
  24
  25     TRACE("(%p)\n", PolicyHandle);
  26
  27     Status = LsapOpenDbObject(NULL,
  28                               NULL,
  29                               L"Policy",
  30                               LsaDbPolicyObject,
  31                               POLICY_ALL_ACCESS,
  32                               &PolicyObject);
  33
  34     if (NT_SUCCESS(Status))
  35         *PolicyHandle = (LSAPR_HANDLE)PolicyObject;
  36
  37     return Status;
  38 }
  39
  40
  41 NTSTATUS
  42 LsarQueryAuditLog(PLSA_DB_OBJECT PolicyObject,
  43                   PLSAPR_POLICY_INFORMATION *PolicyInformation)
  44 {
  45     PPOLICY_AUDIT_LOG_INFO AuditLogInfo = NULL;
  46     ULONG AttributeSize;
  47     NTSTATUS Status;
  48
  49     *PolicyInformation = NULL;
  50
  51     AttributeSize = sizeof(POLICY_AUDIT_LOG_INFO);
  52     AuditLogInfo = MIDL_user_allocate(AttributeSize);
  53     if (AuditLogInfo == NULL)
  54         return STATUS_INSUFFICIENT_RESOURCES;
  55
  56     Status = LsapGetObjectAttribute(PolicyObject,
  57                                     L"PolAdtLg",
  58                                     AuditLogInfo,
  59                                     &AttributeSize);
  60     if (!NT_SUCCESS(Status))
  61     {
  62         MIDL_user_free(AuditLogInfo);
  63     }
  64     else
  65     {
  66         *PolicyInformation = (PLSAPR_POLICY_INFORMATION)AuditLogInfo;
  67     }
  68
  69     return Status;
  70 }
  71
  72
  73 NTSTATUS
  74 LsarQueryAuditEvents(PLSA_DB_OBJECT PolicyObject,
  75                      PLSAPR_POLICY_INFORMATION *PolicyInformation)
  76 {
  77     PLSAP_POLICY_AUDIT_EVENTS_DATA AuditData = NULL;
  78     PLSAPR_POLICY_AUDIT_EVENTS_INFO p = NULL;
  79     ULONG AttributeSize;
  80     NTSTATUS Status = STATUS_SUCCESS;
  81
  82     *PolicyInformation = NULL;
  83
  84     AttributeSize = 0;
  85     Status = LsapGetObjectAttribute(PolicyObject,
  86                                     L"PolAdtEv",
  87                                     NULL,
  88                                     &AttributeSize);
  89     if (!NT_SUCCESS(Status))
  90         return Status;
  91
  92     if (AttributeSize > 0)
  93     {
  94         AuditData = MIDL_user_allocate(AttributeSize);
  95         if (AuditData == NULL)
  96             return STATUS_INSUFFICIENT_RESOURCES;
  97
  98         Status = LsapGetObjectAttribute(PolicyObject,
  99                                         L"PolAdtEv",
 100                                         AuditData,
 101                                         &AttributeSize);
 102         if (!NT_SUCCESS(Status))
 103             goto done;
 104
 105         p = MIDL_user_allocate(sizeof(LSAPR_POLICY_AUDIT_EVENTS_INFO));
 106         if (p == NULL)
 107         {
 108             Status = STATUS_INSUFFICIENT_RESOURCES;
 109             goto done;
 110         }
 111
 112         p->AuditingMode = AuditData->AuditingMode;
 113         p->MaximumAuditEventCount = AuditData->MaximumAuditEventCount;
 114
 115         p->EventAuditingOptions = MIDL_user_allocate(AuditData->MaximumAuditEventCount * sizeof(DWORD));
 116         if (p->EventAuditingOptions == NULL)
 117         {
 118             Status = STATUS_INSUFFICIENT_RESOURCES;
 119             goto done;
 120         }
 121
 122         memcpy(p->EventAuditingOptions,
 123                &(AuditData->AuditEvents[0]),
 124                AuditData->MaximumAuditEventCount * sizeof(DWORD));
 125     }
 126
 127     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 128
 129 done:
 130     if (!NT_SUCCESS(Status))
 131     {
 132         if (p->EventAuditingOptions != NULL)
 133             MIDL_user_free(p->EventAuditingOptions);
 134
 135         if (p != NULL)
 136             MIDL_user_free(p);
 137     }
 138
 139     if (AuditData != NULL)
 140         MIDL_user_free(AuditData);
 141
 142     return STATUS_SUCCESS;
 143 }
 144
 145
 146 NTSTATUS
 147 LsarQueryPrimaryDomain(PLSA_DB_OBJECT PolicyObject,
 148                        PLSAPR_POLICY_INFORMATION *PolicyInformation)
 149 {
 150     PLSAPR_POLICY_PRIMARY_DOM_INFO p = NULL;
 151     PUNICODE_STRING DomainName;
 152     ULONG AttributeSize;
 153     NTSTATUS Status;
 154
 155     *PolicyInformation = NULL;
 156
 157     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_PRIMARY_DOM_INFO));
 158     if (p == NULL)
 159         return STATUS_INSUFFICIENT_RESOURCES;
 160
 161     /* Domain Name */
 162     AttributeSize = 0;
 163     Status = LsapGetObjectAttribute(PolicyObject,
 164                                     L"PolPrDmN",
 165                                     NULL,
 166                                     &AttributeSize);
 167     if (!NT_SUCCESS(Status))
 168     {
 169         goto Done;
 170     }
 171
 172     if (AttributeSize > 0)
 173     {
 174         DomainName = MIDL_user_allocate(AttributeSize);
 175         if (DomainName == NULL)
 176         {
 177             Status = STATUS_INSUFFICIENT_RESOURCES;
 178             goto Done;
 179         }
 180
 181         Status = LsapGetObjectAttribute(PolicyObject,
 182                                         L"PolPrDmN",
 183                                         DomainName,
 184                                         &AttributeSize);
 185         if (Status == STATUS_SUCCESS)
 186         {
 187             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 188
 189             TRACE("PrimaryDomainName: %wZ\n", DomainName);
 190
 191             p->Name.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 192             if (p->Name.Buffer == NULL)
 193             {
 194                 MIDL_user_free(DomainName);
 195                 Status = STATUS_INSUFFICIENT_RESOURCES;
 196                 goto Done;
 197             }
 198
 199             p->Name.Length = DomainName->Length;
 200             p->Name.MaximumLength = DomainName->MaximumLength;
 201             memcpy(p->Name.Buffer,
 202                    DomainName->Buffer,
 203                    DomainName->MaximumLength);
 204         }
 205
 206         MIDL_user_free(DomainName);
 207     }
 208
 209     /* Domain SID */
 210     AttributeSize = 0;
 211     Status = LsapGetObjectAttribute(PolicyObject,
 212                                     L"PolPrDmS",
 213                                     NULL,
 214                                     &AttributeSize);
 215     if (!NT_SUCCESS(Status))
 216     {
 217         goto Done;
 218     }
 219
 220     if (AttributeSize > 0)
 221     {
 222         p->Sid = MIDL_user_allocate(AttributeSize);
 223         if (p->Sid == NULL)
 224         {
 225             Status = STATUS_INSUFFICIENT_RESOURCES;
 226             goto Done;
 227         }
 228
 229         Status = LsapGetObjectAttribute(PolicyObject,
 230                                         L"PolPrDmS",
 231                                         p->Sid,
 232                                         &AttributeSize);
 233     }
 234
 235     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 236
 237 Done:
 238     if (!NT_SUCCESS(Status))
 239     {
 240         if (p)
 241         {
 242             if (p->Name.Buffer)
 243                 MIDL_user_free(p->Name.Buffer);
 244
 245             if (p->Sid)
 246                 MIDL_user_free(p->Sid);
 247
 248             MIDL_user_free(p);
 249         }
 250     }
 251
 252     return Status;
 253 }
 254
 255
 256 NTSTATUS
 257 LsarQueryPdAccount(PLSA_DB_OBJECT PolicyObject,
 258                    PLSAPR_POLICY_INFORMATION *PolicyInformation)
 259 {
 260     PLSAPR_POLICY_PD_ACCOUNT_INFO PdAccountInfo = NULL;
 261
 262     *PolicyInformation = NULL;
 263
 264     PdAccountInfo = MIDL_user_allocate(sizeof(LSAPR_POLICY_PD_ACCOUNT_INFO));
 265     if (PdAccountInfo == NULL)
 266         return STATUS_INSUFFICIENT_RESOURCES;
 267
 268     PdAccountInfo->Name.Length = 0;
 269     PdAccountInfo->Name.MaximumLength = 0;
 270     PdAccountInfo->Name.Buffer = NULL;
 271
 272     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)PdAccountInfo;
 273
 274     return STATUS_SUCCESS;
 275 }
 276
 277
 278 NTSTATUS
 279 LsarQueryAccountDomain(PLSA_DB_OBJECT PolicyObject,
 280                        PLSAPR_POLICY_INFORMATION *PolicyInformation)
 281 {
 282     PLSAPR_POLICY_ACCOUNT_DOM_INFO p = NULL;
 283     PUNICODE_STRING DomainName;
 284     ULONG AttributeSize = 0;
 285     NTSTATUS Status;
 286
 287     *PolicyInformation = NULL;
 288
 289     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_ACCOUNT_DOM_INFO));
 290     if (p == NULL)
 291         return STATUS_INSUFFICIENT_RESOURCES;
 292
 293     /* Domain Name */
 294     Status = LsapGetObjectAttribute(PolicyObject,
 295                                     L"PolAcDmN",
 296                                     NULL,
 297                                     &AttributeSize);
 298     if (!NT_SUCCESS(Status))
 299     {
 300         goto Done;
 301     }
 302
 303     if (AttributeSize > 0)
 304     {
 305         DomainName = MIDL_user_allocate(AttributeSize);
 306         if (DomainName == NULL)
 307         {
 308             Status = STATUS_INSUFFICIENT_RESOURCES;
 309             goto Done;
 310         }
 311
 312         Status = LsapGetObjectAttribute(PolicyObject,
 313                                         L"PolAcDmN",
 314                                         DomainName,
 315                                         &AttributeSize);
 316         if (Status == STATUS_SUCCESS)
 317         {
 318             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 319
 320             TRACE("AccountDomainName: %wZ\n", DomainName);
 321
 322             p->DomainName.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 323             if (p->DomainName.Buffer == NULL)
 324             {
 325                 MIDL_user_free(DomainName);
 326                 Status = STATUS_INSUFFICIENT_RESOURCES;
 327                 goto Done;
 328             }
 329
 330             p->DomainName.Length = DomainName->Length;
 331             p->DomainName.MaximumLength = DomainName->MaximumLength;
 332             memcpy(p->DomainName.Buffer,
 333                    DomainName->Buffer,
 334                    DomainName->MaximumLength);
 335         }
 336
 337         MIDL_user_free(DomainName);
 338     }
 339
 340     /* Domain SID */
 341     AttributeSize = 0;
 342     Status = LsapGetObjectAttribute(PolicyObject,
 343                                     L"PolAcDmS",
 344                                     NULL,
 345                                     &AttributeSize);
 346     if (!NT_SUCCESS(Status))
 347     {
 348         goto Done;
 349     }
 350
 351     if (AttributeSize > 0)
 352     {
 353         p->Sid = MIDL_user_allocate(AttributeSize);
 354         if (p->Sid == NULL)
 355         {
 356             Status = STATUS_INSUFFICIENT_RESOURCES;
 357             goto Done;
 358         }
 359
 360         Status = LsapGetObjectAttribute(PolicyObject,
 361                                         L"PolAcDmS",
 362                                         p->Sid,
 363                                         &AttributeSize);
 364     }
 365
 366     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 367
 368 Done:
 369     if (!NT_SUCCESS(Status))
 370     {
 371         if (p)
 372         {
 373             if (p->DomainName.Buffer)
 374                 MIDL_user_free(p->DomainName.Buffer);
 375
 376             if (p->Sid)
 377                 MIDL_user_free(p->Sid);
 378
 379             MIDL_user_free(p);
 380         }
 381     }
 382
 383     return Status;
 384 }
 385
 386
 387 NTSTATUS
 388 LsarQueryServerRole(PLSA_DB_OBJECT PolicyObject,
 389                     PLSAPR_POLICY_INFORMATION *PolicyInformation)
 390 {
 391     PPOLICY_LSA_SERVER_ROLE_INFO ServerRoleInfo = NULL;
 392     ULONG AttributeSize;
 393     NTSTATUS Status;
 394
 395     *PolicyInformation = NULL;
 396
 397     AttributeSize = sizeof(POLICY_LSA_SERVER_ROLE_INFO);
 398     ServerRoleInfo = MIDL_user_allocate(AttributeSize);
 399     if (ServerRoleInfo == NULL)
 400         return STATUS_INSUFFICIENT_RESOURCES;
 401
 402     Status = LsapGetObjectAttribute(PolicyObject,
 403                                     L"PolSrvRo",
 404                                     ServerRoleInfo,
 405                                     &AttributeSize);
 406     if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
 407     {
 408         ServerRoleInfo->LsaServerRole = PolicyServerRolePrimary;
 409         Status = STATUS_SUCCESS;
 410     }
 411
 412     if (!NT_SUCCESS(Status))
 413     {
 414         MIDL_user_free(ServerRoleInfo);
 415     }
 416     else
 417     {
 418         *PolicyInformation = (PLSAPR_POLICY_INFORMATION)ServerRoleInfo;
 419     }
 420
 421     return Status;
 422 }
 423
 424
 425 NTSTATUS
 426 LsarQueryReplicaSource(PLSA_DB_OBJECT PolicyObject,
 427                        PLSAPR_POLICY_INFORMATION *PolicyInformation)
 428 {
 429     FIXME("\n");
 430     *PolicyInformation = NULL;
 431     return STATUS_NOT_IMPLEMENTED;
 432 }
 433
 434
 435 NTSTATUS
 436 LsarQueryDefaultQuota(PLSA_DB_OBJECT PolicyObject,
 437                       PLSAPR_POLICY_INFORMATION *PolicyInformation)
 438 {
 439     PPOLICY_DEFAULT_QUOTA_INFO QuotaInfo = NULL;
 440     ULONG AttributeSize;
 441     NTSTATUS Status;
 442
 443     *PolicyInformation = NULL;
 444
 445     AttributeSize = sizeof(POLICY_DEFAULT_QUOTA_INFO);
 446     QuotaInfo = MIDL_user_allocate(AttributeSize);
 447     if (QuotaInfo == NULL)
 448         return STATUS_INSUFFICIENT_RESOURCES;
 449
 450     Status = LsapGetObjectAttribute(PolicyObject,
 451                                     L"DefQuota",
 452                                     QuotaInfo,
 453                                     &AttributeSize);
 454     if (!NT_SUCCESS(Status))
 455     {
 456         MIDL_user_free(QuotaInfo);
 457     }
 458     else
 459     {
 460         *PolicyInformation = (PLSAPR_POLICY_INFORMATION)QuotaInfo;
 461     }
 462
 463     return Status;
 464 }
 465
 466
 467 NTSTATUS
 468 LsarQueryModification(PLSA_DB_OBJECT PolicyObject,
 469                       PLSAPR_POLICY_INFORMATION *PolicyInformation)
 470 {
 471     PPOLICY_MODIFICATION_INFO Info = NULL;
 472     ULONG AttributeSize;
 473     NTSTATUS Status;
 474
 475     *PolicyInformation = NULL;
 476
 477     AttributeSize = sizeof(POLICY_MODIFICATION_INFO);
 478     Info = MIDL_user_allocate(AttributeSize);
 479     if (Info == NULL)
 480         return STATUS_INSUFFICIENT_RESOURCES;
 481
 482     Status = LsapGetObjectAttribute(PolicyObject,
 483                                     L"PolMod",
 484                                     Info,
 485                                     &AttributeSize);
 486     if (!NT_SUCCESS(Status))
 487     {
 488         MIDL_user_free(Info);
 489     }
 490     else
 491     {
 492         *PolicyInformation = (PLSAPR_POLICY_INFORMATION)Info;
 493     }
 494
 495     return Status;
 496 }
 497
 498
 499 NTSTATUS
 500 LsarQueryAuditFull(PLSA_DB_OBJECT PolicyObject,
 501                    PLSAPR_POLICY_INFORMATION *PolicyInformation)
 502 {
 503     PPOLICY_AUDIT_FULL_QUERY_INFO AuditFullInfo = NULL;
 504     ULONG AttributeSize;
 505     NTSTATUS Status;
 506
 507     *PolicyInformation = NULL;
 508
 509     AttributeSize = sizeof(POLICY_AUDIT_FULL_QUERY_INFO);
 510     AuditFullInfo = MIDL_user_allocate(AttributeSize);
 511     if (AuditFullInfo == NULL)
 512         return STATUS_INSUFFICIENT_RESOURCES;
 513
 514     Status = LsapGetObjectAttribute(PolicyObject,
 515                                     L"PolAdtFl",
 516                                     AuditFullInfo,
 517                                     &AttributeSize);
 518     if (!NT_SUCCESS(Status))
 519     {
 520         MIDL_user_free(AuditFullInfo);
 521     }
 522     else
 523     {
 524         *PolicyInformation = (PLSAPR_POLICY_INFORMATION)AuditFullInfo;
 525     }
 526
 527     return Status;
 528 }
 529
 530
 531 NTSTATUS
 532 LsarQueryDnsDomain(PLSA_DB_OBJECT PolicyObject,
 533                    PLSAPR_POLICY_INFORMATION *PolicyInformation)
 534 {
 535     PLSAPR_POLICY_DNS_DOMAIN_INFO p = NULL;
 536     PUNICODE_STRING DomainName;
 537     ULONG AttributeSize;
 538     NTSTATUS Status;
 539
 540     *PolicyInformation = NULL;
 541
 542     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_DNS_DOMAIN_INFO));
 543     if (p == NULL)
 544         return STATUS_INSUFFICIENT_RESOURCES;
 545
 546     /* Primary Domain Name */
 547     AttributeSize = 0;
 548     Status = LsapGetObjectAttribute(PolicyObject,
 549                                     L"PolPrDmN",
 550                                     NULL,
 551                                     &AttributeSize);
 552     if (!NT_SUCCESS(Status))
 553     {
 554         goto done;
 555     }
 556
 557     if (AttributeSize > 0)
 558     {
 559         DomainName = MIDL_user_allocate(AttributeSize);
 560         if (DomainName == NULL)
 561         {
 562             Status = STATUS_INSUFFICIENT_RESOURCES;
 563             goto done;
 564         }
 565
 566         Status = LsapGetObjectAttribute(PolicyObject,
 567                                         L"PolPrDmN",
 568                                         DomainName,
 569                                         &AttributeSize);
 570         if (Status == STATUS_SUCCESS)
 571         {
 572             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 573
 574             TRACE("PrimaryDomainName: %wZ\n", DomainName);
 575
 576             p->Name.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 577             if (p->Name.Buffer == NULL)
 578             {
 579                 MIDL_user_free(DomainName);
 580                 Status = STATUS_INSUFFICIENT_RESOURCES;
 581                 goto done;
 582             }
 583
 584             p->Name.Length = DomainName->Length;
 585             p->Name.MaximumLength = DomainName->MaximumLength;
 586             memcpy(p->Name.Buffer,
 587                    DomainName->Buffer,
 588                    DomainName->MaximumLength);
 589         }
 590
 591         MIDL_user_free(DomainName);
 592     }
 593
 594     /* Primary Domain SID */
 595     AttributeSize = 0;
 596     Status = LsapGetObjectAttribute(PolicyObject,
 597                                     L"PolPrDmS",
 598                                     NULL,
 599                                     &AttributeSize);
 600     if (!NT_SUCCESS(Status))
 601     {
 602         goto done;
 603     }
 604
 605     if (AttributeSize > 0)
 606     {
 607         p->Sid = MIDL_user_allocate(AttributeSize);
 608         if (p->Sid == NULL)
 609         {
 610             Status = STATUS_INSUFFICIENT_RESOURCES;
 611             goto done;
 612         }
 613
 614         Status = LsapGetObjectAttribute(PolicyObject,
 615                                         L"PolPrDmS",
 616                                         p->Sid,
 617                                         &AttributeSize);
 618     }
 619
 620     /* DNS Domain Name */
 621     AttributeSize = 0;
 622     Status = LsapGetObjectAttribute(PolicyObject,
 623                                     L"PolDnDDN",
 624                                     NULL,
 625                                     &AttributeSize);
 626     if (!NT_SUCCESS(Status))
 627         goto done;
 628
 629     if (AttributeSize > 0)
 630     {
 631         DomainName = MIDL_user_allocate(AttributeSize);
 632         if (DomainName == NULL)
 633         {
 634             Status = STATUS_INSUFFICIENT_RESOURCES;
 635             goto done;
 636         }
 637
 638         Status = LsapGetObjectAttribute(PolicyObject,
 639                                         L"PolDnDDN",
 640                                         DomainName,
 641                                         &AttributeSize);
 642         if (Status == STATUS_SUCCESS)
 643         {
 644             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 645
 646             TRACE("DNS Domain Name: %wZ\n", DomainName);
 647
 648             p->DnsDomainName.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 649             if (p->DnsDomainName.Buffer == NULL)
 650             {
 651                 MIDL_user_free(DomainName);
 652                 Status = STATUS_INSUFFICIENT_RESOURCES;
 653                 goto done;
 654             }
 655
 656             p->DnsDomainName.Length = DomainName->Length;
 657             p->DnsDomainName.MaximumLength = DomainName->MaximumLength;
 658             memcpy(p->DnsDomainName.Buffer,
 659                    DomainName->Buffer,
 660                    DomainName->MaximumLength);
 661         }
 662
 663         MIDL_user_free(DomainName);
 664     }
 665
 666     /* DNS Forest Name */
 667     AttributeSize = 0;
 668     Status = LsapGetObjectAttribute(PolicyObject,
 669                                     L"PolDnTrN",
 670                                     NULL,
 671                                     &AttributeSize);
 672     if (!NT_SUCCESS(Status))
 673         goto done;
 674
 675     if (AttributeSize > 0)
 676     {
 677         DomainName = MIDL_user_allocate(AttributeSize);
 678         if (DomainName == NULL)
 679         {
 680             Status = STATUS_INSUFFICIENT_RESOURCES;
 681             goto done;
 682         }
 683
 684         Status = LsapGetObjectAttribute(PolicyObject,
 685                                         L"PolDnTrN",
 686                                         DomainName,
 687                                         &AttributeSize);
 688         if (Status == STATUS_SUCCESS)
 689         {
 690             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
 691
 692             TRACE("DNS Forest Name: %wZ\n", DomainName);
 693
 694             p->DnsForestName.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
 695             if (p->DnsForestName.Buffer == NULL)
 696             {
 697                 MIDL_user_free(DomainName);
 698                 Status = STATUS_INSUFFICIENT_RESOURCES;
 699                 goto done;
 700             }
 701
 702             p->DnsForestName.Length = DomainName->Length;
 703             p->DnsForestName.MaximumLength = DomainName->MaximumLength;
 704             memcpy(p->DnsForestName.Buffer,
 705                    DomainName->Buffer,
 706                    DomainName->MaximumLength);
 707         }
 708
 709         MIDL_user_free(DomainName);
 710     }
 711
 712     /* DNS Domain GUID */
 713     AttributeSize = sizeof(GUID);
 714     Status = LsapGetObjectAttribute(PolicyObject,
 715                                     L"PolDnDmG",
 716                                     &(p->DomainGuid),
 717                                     &AttributeSize);
 718     if (!NT_SUCCESS(Status))
 719         goto done;
 720
 721     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
 722
 723 done:
 724     if (!NT_SUCCESS(Status))
 725     {
 726         if (p)
 727         {
 728             if (p->Name.Buffer)
 729                 MIDL_user_free(p->Name.Buffer);
 730
 731             if (p->DnsDomainName.Buffer)
 732                 MIDL_user_free(p->DnsDomainName.Buffer);
 733
 734             if (p->DnsForestName.Buffer)
 735                 MIDL_user_free(p->DnsForestName.Buffer);
 736
 737             if (p->Sid)
 738                 MIDL_user_free(p->Sid);
 739
 740             MIDL_user_free(p);
 741         }
 742     }
 743
 744     return Status;
 745 }
 746
 747
 748 NTSTATUS
 749 LsarQueryDnsDomainInt(PLSA_DB_OBJECT PolicyObject,
 750                       PLSAPR_POLICY_INFORMATION *PolicyInformation)
 751 {
 752     FIXME("\n");
 753     *PolicyInformation = NULL;
 754     return STATUS_NOT_IMPLEMENTED;
 755 }
 756
 757
 758 NTSTATUS
 759 LsarQueryLocalAccountDomain(PLSA_DB_OBJECT PolicyObject,
 760                             PLSAPR_POLICY_INFORMATION *PolicyInformation)
 761 {
 762     FIXME("\n");
 763     *PolicyInformation = NULL;
 764     return STATUS_NOT_IMPLEMENTED;
 765 }
 766
 767
 768 NTSTATUS
 769 LsarSetAuditLog(PLSA_DB_OBJECT PolicyObject,
 770                 PPOLICY_AUDIT_LOG_INFO Info)
 771 {
 772     TRACE("(%p %p)\n", PolicyObject, Info);
 773
 774     return LsapSetObjectAttribute(PolicyObject,
 775                                   L"PolAdtLg",
 776                                   Info,
 777                                   sizeof(POLICY_AUDIT_LOG_INFO));
 778 }
 779
 780
 781 NTSTATUS
 782 LsarSetAuditEvents(PLSA_DB_OBJECT PolicyObject,
 783                    PLSAPR_POLICY_AUDIT_EVENTS_INFO Info)
 784 {
 785     FIXME("\n");
 786     return STATUS_NOT_IMPLEMENTED;
 787 }
 788
 789
 790 NTSTATUS
 791 LsarSetPrimaryDomain(PLSA_DB_OBJECT PolicyObject,
 792                      PLSAPR_POLICY_PRIMARY_DOM_INFO Info)
 793 {
 794     PUNICODE_STRING Buffer;
 795     ULONG Length = 0;
 796     NTSTATUS Status;
 797     LPWSTR Ptr;
 798
 799     TRACE("(%p %p)\n", PolicyObject, Info);
 800
 801     Length = sizeof(UNICODE_STRING) + Info->Name.MaximumLength;
 802     Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
 803                              0,
 804                              Length);
 805     if (Buffer == NULL)
 806         return STATUS_INSUFFICIENT_RESOURCES;
 807
 808     Buffer->Length = Info->Name.Length;
 809     Buffer->MaximumLength = Info->Name.MaximumLength;
 810     Buffer->Buffer = (LPWSTR)sizeof(UNICODE_STRING);
 811     Ptr = (LPWSTR)((ULONG_PTR)Buffer + sizeof(UNICODE_STRING));
 812     memcpy(Ptr, Info->Name.Buffer, Info->Name.MaximumLength);
 813
 814     Status = LsapSetObjectAttribute(PolicyObject,
 815                                     L"PolPrDmN",
 816                                     Buffer,
 817                                     Length);
 818
 819     RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
 820
 821     if (!NT_SUCCESS(Status))
 822         return Status;
 823
 824     Length = 0;
 825     if (Info->Sid != NULL)
 826         Length = RtlLengthSid(Info->Sid);
 827
 828     Status = LsapSetObjectAttribute(PolicyObject,
 829                                     L"PolPrDmS",
 830                                     (LPBYTE)Info->Sid,
 831                                     Length);
 832
 833     return Status;
 834 }
 835
 836
 837 NTSTATUS
 838 LsarSetAccountDomain(PLSA_DB_OBJECT PolicyObject,
 839                      PLSAPR_POLICY_ACCOUNT_DOM_INFO Info)
 840 {
 841     PUNICODE_STRING Buffer;
 842     ULONG Length = 0;
 843     NTSTATUS Status;
 844     LPWSTR Ptr;
 845
 846     TRACE("(%p %p)\n", PolicyObject, Info);
 847
 848     Length = sizeof(UNICODE_STRING) + Info->DomainName.MaximumLength;
 849     Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
 850                              0,
 851                              Length);
 852     if (Buffer == NULL)
 853         return STATUS_INSUFFICIENT_RESOURCES;
 854
 855     Buffer->Length = Info->DomainName.Length;
 856     Buffer->MaximumLength = Info->DomainName.MaximumLength;
 857     Buffer->Buffer = (LPWSTR)sizeof(UNICODE_STRING);
 858     Ptr = (LPWSTR)((ULONG_PTR)Buffer + sizeof(UNICODE_STRING));
 859     memcpy(Ptr, Info->DomainName.Buffer, Info->DomainName.MaximumLength);
 860
 861     Status = LsapSetObjectAttribute(PolicyObject,
 862                                     L"PolAcDmN",
 863                                     Buffer,
 864                                     Length);
 865
 866     RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
 867
 868     if (!NT_SUCCESS(Status))
 869         return Status;
 870
 871     Length = 0;
 872     if (Info->Sid != NULL)
 873         Length = RtlLengthSid(Info->Sid);
 874
 875     Status = LsapSetObjectAttribute(PolicyObject,
 876                                     L"PolAcDmS",
 877                                     (LPBYTE)Info->Sid,
 878                                     Length);
 879
 880     return Status;
 881 }
 882
 883
 884 NTSTATUS
 885 LsarSetServerRole(PLSA_DB_OBJECT PolicyObject,
 886                   PPOLICY_LSA_SERVER_ROLE_INFO Info)
 887 {
 888     FIXME("\n");
 889     return STATUS_NOT_IMPLEMENTED;
 890 }
 891
 892
 893 NTSTATUS
 894 LsarSetReplicaSource(PLSA_DB_OBJECT PolicyObject,
 895                      PPOLICY_LSA_REPLICA_SRCE_INFO Info)
 896 {
 897     FIXME("\n");
 898     return STATUS_NOT_IMPLEMENTED;
 899 }
 900
 901
 902 NTSTATUS
 903 LsarSetDefaultQuota(PLSA_DB_OBJECT PolicyObject,
 904                     PPOLICY_DEFAULT_QUOTA_INFO Info)
 905 {
 906     TRACE("(%p %p)\n", PolicyObject, Info);
 907
 908     return LsapSetObjectAttribute(PolicyObject,
 909                                   L"DefQuota",
 910                                   Info,
 911                                   sizeof(POLICY_DEFAULT_QUOTA_INFO));
 912 }
 913
 914
 915 NTSTATUS
 916 LsarSetModification(PLSA_DB_OBJECT PolicyObject,
 917                     PPOLICY_MODIFICATION_INFO Info)
 918 {
 919     FIXME("\n");
 920     return STATUS_NOT_IMPLEMENTED;
 921 }
 922
 923
 924 NTSTATUS
 925 LsarSetAuditFull(PLSA_DB_OBJECT PolicyObject,
 926                  PPOLICY_AUDIT_FULL_QUERY_INFO Info)
 927 {
 928     FIXME("\n");
 929     return STATUS_NOT_IMPLEMENTED;
 930 }
 931
 932
 933 NTSTATUS
 934 LsarSetDnsDomain(PLSA_DB_OBJECT PolicyObject,
 935                  PLSAPR_POLICY_DNS_DOMAIN_INFO Info)
 936 {
 937     FIXME("\n");
 938     return STATUS_NOT_IMPLEMENTED;
 939 }
 940
 941
 942 NTSTATUS
 943 LsarSetDnsDomainInt(PLSA_DB_OBJECT PolicyObject,
 944                     PLSAPR_POLICY_DNS_DOMAIN_INFO Info)
 945 {
 946     FIXME("\n");
 947     return STATUS_NOT_IMPLEMENTED;
 948 }
 949
 950
 951 NTSTATUS
 952 LsarSetLocalAccountDomain(PLSA_DB_OBJECT PolicyObject,
 953                           PLSAPR_POLICY_ACCOUNT_DOM_INFO Info)
 954 {
 955     FIXME("\n");
 956     return STATUS_NOT_IMPLEMENTED;
 957 }
 958
 959 /* EOF */