ReactOS Development > Doxygen

00001 /*
00002  * PROJECT:     Local Security Authority Server DLL
00003  * LICENSE:     GPL - See COPYING in the top level directory
00004  * FILE:        dll/win32/lsasrv/policy.c
00005  * PURPOSE:     Policy object routines
00006  * COPYRIGHT:   Copyright 2011 Eric Kohl
00007  */
00008 
00009 /* INCLUDES ****************************************************************/
00010 
00011 #include "lsasrv.h"
00012 
00013 WINE_DEFAULT_DEBUG_CHANNEL(lsasrv);
00014 
00015 
00016 /* FUNCTIONS ***************************************************************/
00017 
00018 NTSTATUS
00019 LsarSetPrimaryDomain(PLSA_DB_OBJECT PolicyObject,
00020                      PLSAPR_POLICY_PRIMARY_DOM_INFO Info)
00021 {
00022     PUNICODE_STRING Buffer;
00023     ULONG Length = 0;
00024     NTSTATUS Status;
00025     LPWSTR Ptr;
00026 
00027     TRACE("LsarSetPrimaryDomain(%p, %p)\n", PolicyObject, Info);
00028 
00029     Length = sizeof(UNICODE_STRING) + Info->Name.MaximumLength;
00030     Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
00031                              0,
00032                              Length);
00033     if (Buffer == NULL)
00034         return STATUS_INSUFFICIENT_RESOURCES;
00035 
00036     Buffer->Length = Info->Name.Length;
00037     Buffer->MaximumLength = Info->Name.MaximumLength;
00038     Buffer->Buffer = (LPWSTR)sizeof(UNICODE_STRING);
00039     Ptr = (LPWSTR)((ULONG_PTR)Buffer + sizeof(UNICODE_STRING));
00040     memcpy(Ptr, Info->Name.Buffer, Info->Name.MaximumLength);
00041 
00042     Status = LsapSetObjectAttribute(PolicyObject,
00043                                     L"PolPrDmN",
00044                                     Buffer,
00045                                     Length);
00046 
00047     RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
00048 
00049     if (!NT_SUCCESS(Status))
00050         return Status;
00051 
00052     Length = 0;
00053     if (Info->Sid != NULL)
00054         Length = RtlLengthSid(Info->Sid);
00055 
00056     Status = LsapSetObjectAttribute(PolicyObject,
00057                                     L"PolPrDmS",
00058                                     (LPBYTE)Info->Sid,
00059                                     Length);
00060 
00061     return Status;
00062 }
00063 
00064 
00065 NTSTATUS
00066 LsarSetAccountDomain(PLSA_DB_OBJECT PolicyObject,
00067                      PLSAPR_POLICY_ACCOUNT_DOM_INFO Info)
00068 {
00069     PUNICODE_STRING Buffer;
00070     ULONG Length = 0;
00071     NTSTATUS Status;
00072     LPWSTR Ptr;
00073 
00074     TRACE("LsarSetAccountDomain(%p, %p)\n", PolicyObject, Info);
00075 
00076     Length = sizeof(UNICODE_STRING) + Info->DomainName.MaximumLength;
00077     Buffer = RtlAllocateHeap(RtlGetProcessHeap(),
00078                              0,
00079                              Length);
00080     if (Buffer == NULL)
00081         return STATUS_INSUFFICIENT_RESOURCES;
00082 
00083     Buffer->Length = Info->DomainName.Length;
00084     Buffer->MaximumLength = Info->DomainName.MaximumLength;
00085     Buffer->Buffer = (LPWSTR)sizeof(UNICODE_STRING);
00086     Ptr = (LPWSTR)((ULONG_PTR)Buffer + sizeof(UNICODE_STRING));
00087     memcpy(Ptr, Info->DomainName.Buffer, Info->DomainName.MaximumLength);
00088 
00089     Status = LsapSetObjectAttribute(PolicyObject,
00090                                     L"PolAcDmN",
00091                                     Buffer,
00092                                     Length);
00093 
00094     RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
00095 
00096     if (!NT_SUCCESS(Status))
00097         return Status;
00098 
00099     Length = 0;
00100     if (Info->Sid != NULL)
00101         Length = RtlLengthSid(Info->Sid);
00102 
00103     Status = LsapSetObjectAttribute(PolicyObject,
00104                                     L"PolAcDmS",
00105                                     (LPBYTE)Info->Sid,
00106                                     Length);
00107 
00108     return Status;
00109 }
00110 
00111 
00112 NTSTATUS
00113 LsarSetDnsDomain(PLSA_DB_OBJECT PolicyObject,
00114                  PLSAPR_POLICY_DNS_DOMAIN_INFO Info)
00115 {
00116 
00117     return STATUS_NOT_IMPLEMENTED;
00118 }
00119 
00120 
00121 NTSTATUS
00122 LsarQueryAuditEvents(PLSA_DB_OBJECT PolicyObject,
00123                      PLSAPR_POLICY_INFORMATION *PolicyInformation)
00124 {
00125     PLSAPR_POLICY_AUDIT_EVENTS_INFO p = NULL;
00126 
00127     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_AUDIT_EVENTS_INFO));
00128     if (p == NULL)
00129         return STATUS_INSUFFICIENT_RESOURCES;
00130 
00131     p->AuditingMode = FALSE; /* no auditing */
00132     p->EventAuditingOptions = NULL;
00133     p->MaximumAuditEventCount = 0;
00134 
00135     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
00136 
00137     return STATUS_SUCCESS;
00138 }
00139 
00140 
00141 NTSTATUS
00142 LsarQueryPrimaryDomain(PLSA_DB_OBJECT PolicyObject,
00143                        PLSAPR_POLICY_INFORMATION *PolicyInformation)
00144 {
00145     PLSAPR_POLICY_PRIMARY_DOM_INFO p = NULL;
00146     PUNICODE_STRING DomainName;
00147     ULONG AttributeSize;
00148     NTSTATUS Status;
00149 
00150     *PolicyInformation = NULL;
00151 
00152     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_PRIMARY_DOM_INFO));
00153     if (p == NULL)
00154         return STATUS_INSUFFICIENT_RESOURCES;
00155 
00156     /* Domain Name */
00157     AttributeSize = 0;
00158     Status = LsapGetObjectAttribute(PolicyObject,
00159                                     L"PolPrDmN",
00160                                     NULL,
00161                                     &AttributeSize);
00162     if (!NT_SUCCESS(Status))
00163     {
00164         goto Done;
00165     }
00166 
00167     if (AttributeSize > 0)
00168     {
00169         DomainName = MIDL_user_allocate(AttributeSize);
00170         if (DomainName == NULL)
00171         {
00172             Status = STATUS_INSUFFICIENT_RESOURCES;
00173             goto Done;
00174         }
00175 
00176         Status = LsapGetObjectAttribute(PolicyObject,
00177                                         L"PolPrDmN",
00178                                         DomainName,
00179                                         &AttributeSize);
00180         if (Status == STATUS_SUCCESS)
00181         {
00182             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
00183 
00184             TRACE("PrimaryDomainName: %wZ\n", DomainName);
00185 
00186             p->Name.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
00187             if (p->Name.Buffer == NULL)
00188             {
00189                 MIDL_user_free(DomainName);
00190                 Status = STATUS_INSUFFICIENT_RESOURCES;
00191                 goto Done;
00192             }
00193 
00194             p->Name.Length = DomainName->Length;
00195             p->Name.MaximumLength = DomainName->MaximumLength;
00196             memcpy(p->Name.Buffer,
00197                    DomainName->Buffer,
00198                    DomainName->MaximumLength);
00199         }
00200 
00201         MIDL_user_free(DomainName);
00202     }
00203 
00204     /* Domain SID */
00205     AttributeSize = 0;
00206     Status = LsapGetObjectAttribute(PolicyObject,
00207                                     L"PolPrDmS",
00208                                     NULL,
00209                                     &AttributeSize);
00210     if (!NT_SUCCESS(Status))
00211     {
00212         goto Done;
00213     }
00214 
00215     if (AttributeSize > 0)
00216     {
00217         p->Sid = MIDL_user_allocate(AttributeSize);
00218         if (p->Sid == NULL)
00219         {
00220             Status = STATUS_INSUFFICIENT_RESOURCES;
00221             goto Done;
00222         }
00223 
00224         Status = LsapGetObjectAttribute(PolicyObject,
00225                                         L"PolPrDmS",
00226                                         p->Sid,
00227                                         &AttributeSize);
00228     }
00229 
00230     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
00231 
00232 Done:
00233     if (!NT_SUCCESS(Status))
00234     {
00235         if (p)
00236         {
00237             if (p->Name.Buffer)
00238                 MIDL_user_free(p->Name.Buffer);
00239 
00240             if (p->Sid)
00241                 MIDL_user_free(p->Sid);
00242 
00243             MIDL_user_free(p);
00244         }
00245     }
00246 
00247     return Status;
00248 }
00249 
00250 
00251 NTSTATUS
00252 LsarQueryAccountDomain(PLSA_DB_OBJECT PolicyObject,
00253                        PLSAPR_POLICY_INFORMATION *PolicyInformation)
00254 {
00255     PLSAPR_POLICY_ACCOUNT_DOM_INFO p = NULL;
00256     PUNICODE_STRING DomainName;
00257     ULONG AttributeSize = 0;
00258     NTSTATUS Status;
00259 
00260     *PolicyInformation = NULL;
00261 
00262     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_ACCOUNT_DOM_INFO));
00263     if (p == NULL)
00264         return STATUS_INSUFFICIENT_RESOURCES;
00265 
00266     /* Domain Name */
00267     Status = LsapGetObjectAttribute(PolicyObject,
00268                                     L"PolAcDmN",
00269                                     NULL,
00270                                     &AttributeSize);
00271     if (!NT_SUCCESS(Status))
00272     {
00273         goto Done;
00274     }
00275 
00276     if (AttributeSize > 0)
00277     {
00278         DomainName = MIDL_user_allocate(AttributeSize);
00279         if (DomainName == NULL)
00280         {
00281             Status = STATUS_INSUFFICIENT_RESOURCES;
00282             goto Done;
00283         }
00284 
00285         Status = LsapGetObjectAttribute(PolicyObject,
00286                                         L"PolAcDmN",
00287                                         DomainName,
00288                                         &AttributeSize);
00289         if (Status == STATUS_SUCCESS)
00290         {
00291             DomainName->Buffer = (LPWSTR)((ULONG_PTR)DomainName + (ULONG_PTR)DomainName->Buffer);
00292 
00293             TRACE("AccountDomainName: %wZ\n", DomainName);
00294 
00295             p->DomainName.Buffer = MIDL_user_allocate(DomainName->MaximumLength);
00296             if (p->DomainName.Buffer == NULL)
00297             {
00298                 MIDL_user_free(DomainName);
00299                 Status = STATUS_INSUFFICIENT_RESOURCES;
00300                 goto Done;
00301             }
00302 
00303             p->DomainName.Length = DomainName->Length;
00304             p->DomainName.MaximumLength = DomainName->MaximumLength;
00305             memcpy(p->DomainName.Buffer,
00306                    DomainName->Buffer,
00307                    DomainName->MaximumLength);
00308         }
00309 
00310         MIDL_user_free(DomainName);
00311     }
00312 
00313     /* Domain SID */
00314     AttributeSize = 0;
00315     Status = LsapGetObjectAttribute(PolicyObject,
00316                                     L"PolAcDmS",
00317                                     NULL,
00318                                     &AttributeSize);
00319     if (!NT_SUCCESS(Status))
00320     {
00321         goto Done;
00322     }
00323 
00324     if (AttributeSize > 0)
00325     {
00326         p->Sid = MIDL_user_allocate(AttributeSize);
00327         if (p->Sid == NULL)
00328         {
00329             Status = STATUS_INSUFFICIENT_RESOURCES;
00330             goto Done;
00331         }
00332 
00333         Status = LsapGetObjectAttribute(PolicyObject,
00334                                         L"PolAcDmS",
00335                                         p->Sid,
00336                                         &AttributeSize);
00337     }
00338 
00339     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
00340 
00341 Done:
00342     if (!NT_SUCCESS(Status))
00343     {
00344         if (p)
00345         {
00346             if (p->DomainName.Buffer)
00347                 MIDL_user_free(p->DomainName.Buffer);
00348 
00349             if (p->Sid)
00350                 MIDL_user_free(p->Sid);
00351 
00352             MIDL_user_free(p);
00353         }
00354     }
00355 
00356     return Status;
00357 }
00358 
00359 
00360 NTSTATUS
00361 LsarQueryDnsDomain(PLSA_DB_OBJECT PolicyObject,
00362                    PLSAPR_POLICY_INFORMATION *PolicyInformation)
00363 {
00364     PLSAPR_POLICY_DNS_DOMAIN_INFO p = NULL;
00365 
00366     p = MIDL_user_allocate(sizeof(LSAPR_POLICY_DNS_DOMAIN_INFO));
00367     if (p == NULL)
00368         return STATUS_INSUFFICIENT_RESOURCES;
00369 
00370     p->Name.Length = 0;
00371     p->Name.MaximumLength = 0;
00372     p->Name.Buffer = NULL;
00373 #if 0
00374             p->Name.Length = wcslen(L"COMPUTERNAME");
00375             p->Name.MaximumLength = p->Name.Length + sizeof(WCHAR);
00376             p->Name.Buffer = MIDL_user_allocate(p->Name.MaximumLength);
00377             if (p->Name.Buffer == NULL)
00378             {
00379                 MIDL_user_free(p);
00380                 return STATUS_INSUFFICIENT_RESOURCES;
00381             }
00382 
00383             wcscpy(p->Name.Buffer, L"COMPUTERNAME");
00384 #endif
00385 
00386     p->DnsDomainName.Length = 0;
00387     p->DnsDomainName.MaximumLength = 0;
00388     p->DnsDomainName.Buffer = NULL;
00389 
00390     p->DnsForestName.Length = 0;
00391     p->DnsForestName.MaximumLength = 0;
00392     p->DnsForestName.Buffer = 0;
00393 
00394     memset(&p->DomainGuid, 0, sizeof(GUID));
00395 
00396     p->Sid = NULL; /* no domain, no workgroup */
00397 
00398     *PolicyInformation = (PLSAPR_POLICY_INFORMATION)p;
00399 
00400     return STATUS_SUCCESS;
00401 }
00402 
00403 /* EOF */
Generated on Fri May 25 2012 04:22:04 for ReactOS by
1.7.6.1