xref: /reactos/dll/win32/advapi32/sec/lsa.c (revision 5140a990) 
1 /*
2  * COPYRIGHT:       See COPYING in the top level directory
3  * PROJECT:         ReactOS system libraries
4  * FILE:            dll/win32/advapi32/sec/lsa.c
5  * PURPOSE:         Local security authority functions
6  * PROGRAMMER:      Emanuele Aliberti
7  * UPDATE HISTORY:
8  *      19990322 EA created
9  *      19990515 EA stubs
10  *      20030202 KJK compressed stubs
11  */
12 
13 #include <advapi32.h>
14 
15 #include <lsa_c.h>
16 
17 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
18 
19 static
20 BOOL
21 LsapIsLocalComputer(PLSA_UNICODE_STRING ServerName)
22 {
23     DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
24     BOOL Result;
25     LPWSTR buf;
26     PCWSTR pSrvName;
27 
28     if (ServerName == NULL || ServerName->Length == 0 || ServerName->Buffer == NULL)
29         return TRUE;
30 
31     pSrvName = ServerName->Buffer;
32     buf = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
33     Result = GetComputerNameW(buf, &dwSize);
34     if (Result && (pSrvName[0] == L'\\') && (pSrvName[1] == L'\\'))
35         pSrvName += 2;
36     Result = Result && !lstrcmpW(pSrvName, buf);
37     HeapFree(GetProcessHeap(), 0, buf);
38 
39     return Result;
40 }
41 
42 
43 handle_t
44 __RPC_USER
45 PLSAPR_SERVER_NAME_bind(PLSAPR_SERVER_NAME pszSystemName)
46 {
47     handle_t hBinding = NULL;
48     LPWSTR pszStringBinding;
49     RPC_STATUS status;
50 
51     TRACE("PLSAPR_SERVER_NAME_bind() called\n");
52 
53     status = RpcStringBindingComposeW(NULL,
54                                       L"ncacn_np",
55                                       pszSystemName,
56                                       L"\\pipe\\lsarpc",
57                                       NULL,
58                                       &pszStringBinding);
59     if (status)
60     {
61         TRACE("RpcStringBindingCompose returned 0x%x\n", status);
62         return NULL;
63     }
64 
65     /* Set the binding handle that will be used to bind to the server. */
66     status = RpcBindingFromStringBindingW(pszStringBinding,
67                                           &hBinding);
68     if (status)
69     {
70         TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
71     }
72 
73     status = RpcStringFreeW(&pszStringBinding);
74     if (status)
75     {
76         TRACE("RpcStringFree returned 0x%x\n", status);
77     }
78 
79     return hBinding;
80 }
81 
82 
83 void
84 __RPC_USER
85 PLSAPR_SERVER_NAME_unbind(PLSAPR_SERVER_NAME pszSystemName,
86                           handle_t hBinding)
87 {
88     RPC_STATUS status;
89 
90     TRACE("PLSAPR_SERVER_NAME_unbind() called\n");
91 
92     status = RpcBindingFree(&hBinding);
93     if (status)
94     {
95         TRACE("RpcBindingFree returned 0x%x\n", status);
96     }
97 }
98 
99 
100 /*
101  * @implemented
102  */
103 NTSTATUS
104 WINAPI
105 LsaAddAccountRights(IN LSA_HANDLE PolicyHandle,
106                     IN PSID AccountSid,
107                     IN PLSA_UNICODE_STRING UserRights,
108                     IN ULONG CountOfRights)
109 {
110     LSAPR_USER_RIGHT_SET UserRightSet;
111     NTSTATUS Status;
112 
113     TRACE("LsaAddAccountRights(%p %p %p 0x%08x)\n",
114           PolicyHandle, AccountSid, UserRights, CountOfRights);
115 
116     UserRightSet.Entries = CountOfRights;
117     UserRightSet.UserRights = (PRPC_UNICODE_STRING)UserRights;
118 
119     RpcTryExcept
120     {
121         Status = LsarAddAccountRights((LSAPR_HANDLE)PolicyHandle,
122                                       (PRPC_SID)AccountSid,
123                                       &UserRightSet);
124 
125     }
126     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
127     {
128         Status = I_RpcMapWin32Status(RpcExceptionCode());
129     }
130     RpcEndExcept;
131 
132     return Status;
133 }
134 
135 
136 /*
137  * @implemented
138  */
139 NTSTATUS
140 WINAPI
141 LsaAddPrivilegesToAccount(IN LSA_HANDLE AccountHandle,
142                           IN PPRIVILEGE_SET PrivilegeSet)
143 {
144     NTSTATUS Status;
145 
146     TRACE("LsaAddPrivilegesToAccount(%p %p)\n",
147           AccountHandle, PrivilegeSet);
148 
149     RpcTryExcept
150     {
151         Status = LsarAddPrivilegesToAccount((LSAPR_HANDLE)AccountHandle,
152                                             (PLSAPR_PRIVILEGE_SET)PrivilegeSet);
153     }
154     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
155     {
156         Status = I_RpcMapWin32Status(RpcExceptionCode());
157     }
158     RpcEndExcept;
159 
160     return Status;
161 }
162 
163 
164 /*
165  * @implemented
166  */
167 NTSTATUS
168 WINAPI
169 LsaClearAuditLog(IN LSA_HANDLE PolicyHandle)
170 {
171     NTSTATUS Status;
172 
173     TRACE("LsaClearAuditLog(%p)\n", PolicyHandle);
174 
175     RpcTryExcept
176     {
177         Status = LsarClearAuditLog((LSAPR_HANDLE)PolicyHandle);
178     }
179     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
180     {
181         Status = I_RpcMapWin32Status(RpcExceptionCode());
182     }
183     RpcEndExcept;
184 
185     return Status;
186 }
187 
188 
189 /*
190  * @implemented
191  */
192 NTSTATUS
193 WINAPI
194 LsaClose(IN LSA_HANDLE ObjectHandle)
195 {
196     NTSTATUS Status;
197 
198     TRACE("LsaClose(%p) called\n", ObjectHandle);
199 
200     RpcTryExcept
201     {
202         Status = LsarClose((PLSAPR_HANDLE)&ObjectHandle);
203     }
204     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
205     {
206         Status = I_RpcMapWin32Status(RpcExceptionCode());
207     }
208     RpcEndExcept;
209 
210     return Status;
211 }
212 
213 
214 /*
215  * @implemented
216  */
217 NTSTATUS
218 WINAPI
219 LsaCreateAccount(IN LSA_HANDLE PolicyHandle,
220                  IN PSID AccountSid,
221                  IN ACCESS_MASK DesiredAccess,
222                  OUT PLSA_HANDLE AccountHandle)
223 {
224     NTSTATUS Status;
225 
226     TRACE("LsaCreateAccount(%p %p 0x%08lx %p)\n",
227           PolicyHandle, AccountSid, DesiredAccess, AccountHandle);
228 
229     RpcTryExcept
230     {
231         Status = LsarCreateAccount((LSAPR_HANDLE)PolicyHandle,
232                                    AccountSid,
233                                    DesiredAccess,
234                                    AccountHandle);
235     }
236     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
237     {
238         Status = I_RpcMapWin32Status(RpcExceptionCode());
239     }
240     RpcEndExcept;
241 
242     return Status;
243 }
244 
245 
246 /*
247  * @implemented
248  */
249 NTSTATUS
250 WINAPI
251 LsaCreateSecret(IN LSA_HANDLE PolicyHandle,
252                 IN PLSA_UNICODE_STRING SecretName,
253                 IN ACCESS_MASK DesiredAccess,
254                 OUT PLSA_HANDLE SecretHandle)
255 {
256     NTSTATUS Status;
257 
258     TRACE("LsaCreateSecret(%p %p 0x%08lx %p)\n",
259           PolicyHandle, SecretName, DesiredAccess, SecretHandle);
260 
261     RpcTryExcept
262     {
263         Status = LsarCreateSecret((LSAPR_HANDLE)PolicyHandle,
264                                   (PRPC_UNICODE_STRING)SecretName,
265                                   DesiredAccess,
266                                   SecretHandle);
267     }
268     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
269     {
270         Status = I_RpcMapWin32Status(RpcExceptionCode());
271     }
272     RpcEndExcept;
273 
274     return Status;
275 }
276 
277 
278 /*
279  * @implemented
280  */
281 NTSTATUS
282 WINAPI
283 LsaCreateTrustedDomain(IN LSA_HANDLE PolicyHandle,
284                        IN PLSA_TRUST_INFORMATION TrustedDomainInformation,
285                        IN ACCESS_MASK DesiredAccess,
286                        OUT PLSA_HANDLE TrustedDomainHandle)
287 {
288     NTSTATUS Status;
289 
290     TRACE("LsaCreateTrustedDomain(%p %p 0x%08lx %p)\n",
291           PolicyHandle, TrustedDomainInformation, DesiredAccess, TrustedDomainHandle);
292 
293     RpcTryExcept
294     {
295         Status = LsarCreateTrustedDomain((LSAPR_HANDLE)PolicyHandle,
296                                          (PLSAPR_TRUST_INFORMATION)TrustedDomainInformation,
297                                          DesiredAccess,
298                                          (PLSAPR_HANDLE)TrustedDomainHandle);
299     }
300     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
301     {
302         Status = I_RpcMapWin32Status(RpcExceptionCode());
303     }
304     RpcEndExcept;
305 
306     return Status;
307 }
308 
309 
310 /*
311  * @unimplemented
312  */
313 NTSTATUS
314 WINAPI
315 LsaCreateTrustedDomainEx(IN LSA_HANDLE PolicyHandle,
316                          IN PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
317                          IN PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation,
318                          IN ACCESS_MASK DesiredAccess,
319                          OUT PLSA_HANDLE TrustedDomainHandle)
320 {
321     PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION_INTERNAL EncryptedAuthInfo = NULL;
322     NTSTATUS Status;
323 
324     TRACE("LsaCreateTrustedDomainEx(%p %p %p 0x%08lx %p) stub\n",
325           PolicyHandle, TrustedDomainInformation, AuthenticationInformation,
326           DesiredAccess, TrustedDomainHandle);
327 
328     RpcTryExcept
329     {
330         /* FIXME: Encrypt AuthenticationInformation */
331 
332         Status = LsarCreateTrustedDomainEx2((LSAPR_HANDLE)PolicyHandle,
333                                             (PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX)TrustedDomainInformation,
334                                             EncryptedAuthInfo,
335                                             DesiredAccess,
336                                             (PLSAPR_HANDLE)TrustedDomainHandle);
337     }
338     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
339     {
340         Status = I_RpcMapWin32Status(RpcExceptionCode());
341     }
342     RpcEndExcept;
343 
344     return Status;
345 }
346 
347 
348 /*
349  * @implemented
350  */
351 NTSTATUS
352 WINAPI
353 LsaDelete(IN LSA_HANDLE ObjectHandle)
354 {
355     NTSTATUS Status;
356 
357     TRACE("LsaDelete(%p)\n", ObjectHandle);
358 
359     RpcTryExcept
360     {
361         Status = LsarDelete((LSAPR_HANDLE)ObjectHandle);
362     }
363     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
364     {
365         Status = I_RpcMapWin32Status(RpcExceptionCode());
366     }
367     RpcEndExcept;
368 
369     return Status;
370 }
371 
372 
373 /*
374  * @implemented
375  */
376 NTSTATUS
377 WINAPI
378 LsaDeleteTrustedDomain(IN LSA_HANDLE PolicyHandle,
379                        IN PSID TrustedDomainSid)
380 {
381     NTSTATUS Status;
382 
383     TRACE("LsaDeleteTrustedDomain(%p %p)\n",
384           PolicyHandle, TrustedDomainSid);
385 
386     RpcTryExcept
387     {
388         Status = LsarDeleteTrustedDomain((LSAPR_HANDLE)PolicyHandle,
389                                          TrustedDomainSid);
390     }
391     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
392     {
393         Status = I_RpcMapWin32Status(RpcExceptionCode());
394     }
395     RpcEndExcept;
396 
397     return Status;
398 }
399 
400 
401 /*
402  * @implemented
403  */
404 NTSTATUS
405 WINAPI
406 LsaEnumerateAccountRights(IN LSA_HANDLE PolicyHandle,
407                           IN PSID AccountSid,
408                           OUT PLSA_UNICODE_STRING *UserRights,
409                           OUT PULONG CountOfRights)
410 {
411     LSAPR_USER_RIGHT_SET UserRightsSet;
412     NTSTATUS Status;
413 
414     TRACE("LsaEnumerateAccountRights(%p %p %p %p)\n",
415           PolicyHandle, AccountSid, UserRights, CountOfRights);
416 
417     UserRightsSet.Entries = 0;
418     UserRightsSet.UserRights = NULL;
419 
420     RpcTryExcept
421     {
422         Status = LsarEnumerateAccountRights((LSAPR_HANDLE)PolicyHandle,
423                                             AccountSid,
424                                             &UserRightsSet);
425 
426         *UserRights = (PUNICODE_STRING)UserRightsSet.UserRights;
427         *CountOfRights = UserRightsSet.Entries;
428     }
429     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
430     {
431         Status = I_RpcMapWin32Status(RpcExceptionCode());
432 
433         if (UserRightsSet.UserRights != NULL)
434             MIDL_user_free(UserRightsSet.UserRights);
435     }
436     RpcEndExcept;
437 
438     return Status;
439 }
440 
441 
442 /*
443  * @implemented
444  */
445 NTSTATUS
446 WINAPI
447 LsaEnumerateAccounts(IN LSA_HANDLE PolicyHandle,
448                      IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext,
449                      OUT PVOID *Buffer,
450                      IN ULONG PreferedMaximumLength,
451                      OUT PULONG CountReturned)
452 {
453     LSAPR_ACCOUNT_ENUM_BUFFER AccountEnumBuffer;
454     NTSTATUS Status;
455 
456     TRACE("LsaEnumerateAccounts(%p %p %p %lu %p)\n",
457           PolicyHandle, EnumerationContext, Buffer,
458           PreferedMaximumLength, CountReturned);
459 
460     AccountEnumBuffer.EntriesRead = 0;
461     AccountEnumBuffer.Information = NULL;
462 
463     RpcTryExcept
464     {
465         Status = LsarEnumerateAccounts((LSAPR_HANDLE)PolicyHandle,
466                                        EnumerationContext,
467                                        &AccountEnumBuffer,
468                                        PreferedMaximumLength);
469 
470         *Buffer = AccountEnumBuffer.Information;
471         *CountReturned = AccountEnumBuffer.EntriesRead;
472     }
473     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
474     {
475         if (AccountEnumBuffer.Information != NULL)
476             MIDL_user_free(AccountEnumBuffer.Information);
477 
478         Status = I_RpcMapWin32Status(RpcExceptionCode());
479     }
480     RpcEndExcept;
481 
482     return Status;
483 }
484 
485 
486 /*
487  * @implemented
488  */
489 NTSTATUS
490 WINAPI
491 LsaEnumerateAccountsWithUserRight(IN LSA_HANDLE PolicyHandle,
492                                   IN PLSA_UNICODE_STRING UserRight OPTIONAL,
493                                   OUT PVOID *Buffer,
494                                   OUT PULONG CountReturned)
495 {
496     LSAPR_ACCOUNT_ENUM_BUFFER AccountEnumBuffer;
497     NTSTATUS Status;
498 
499     TRACE("LsaEnumerateAccountsWithUserRight(%p %p %p %p) stub\n",
500           PolicyHandle, UserRight, Buffer, CountReturned);
501 
502     AccountEnumBuffer.EntriesRead = 0;
503     AccountEnumBuffer.Information = NULL;
504 
505     RpcTryExcept
506     {
507         Status = LsarEnumerateAccountsWithUserRight((LSAPR_HANDLE)PolicyHandle,
508                                                     (PRPC_UNICODE_STRING)UserRight,
509                                                     &AccountEnumBuffer);
510 
511         *Buffer = AccountEnumBuffer.Information;
512         *CountReturned = AccountEnumBuffer.EntriesRead;
513     }
514     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
515     {
516         if (AccountEnumBuffer.Information != NULL)
517             MIDL_user_free(AccountEnumBuffer.Information);
518 
519         Status = I_RpcMapWin32Status(RpcExceptionCode());
520     }
521     RpcEndExcept;
522 
523     return Status;
524 }
525 
526 
527 /*
528  * @implemented
529  */
530 NTSTATUS
531 WINAPI
532 LsaEnumeratePrivileges(IN LSA_HANDLE PolicyHandle,
533                        IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext,
534                        OUT PVOID *Buffer,
535                        IN ULONG PreferedMaximumLength,
536                        OUT PULONG CountReturned)
537 {
538     LSAPR_PRIVILEGE_ENUM_BUFFER PrivilegeEnumBuffer;
539     NTSTATUS Status;
540 
541     TRACE("LsaEnumeratePrivileges(%p %p %p %lu %p)\n",
542           PolicyHandle, EnumerationContext, Buffer,
543           PreferedMaximumLength, CountReturned);
544 
545     PrivilegeEnumBuffer.Entries = 0;
546     PrivilegeEnumBuffer.Privileges = NULL;
547 
548     RpcTryExcept
549     {
550         Status = LsarEnumeratePrivileges((LSAPR_HANDLE)PolicyHandle,
551                                          EnumerationContext,
552                                          &PrivilegeEnumBuffer,
553                                          PreferedMaximumLength);
554 
555         *Buffer = PrivilegeEnumBuffer.Privileges;
556         *CountReturned = PrivilegeEnumBuffer.Entries;
557 
558     }
559     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
560     {
561         if (PrivilegeEnumBuffer.Privileges != NULL)
562             MIDL_user_free(PrivilegeEnumBuffer.Privileges);
563 
564         Status = I_RpcMapWin32Status(RpcExceptionCode());
565     }
566     RpcEndExcept;
567 
568     return Status;
569 }
570 
571 
572 /*
573  * @implemented
574  */
575 NTSTATUS
576 WINAPI
577 LsaEnumeratePrivilegesOfAccount(IN LSA_HANDLE AccountHandle,
578                                 OUT PPRIVILEGE_SET *Privileges)
579 {
580     NTSTATUS Status;
581 
582     TRACE("LsaEnumeratePrivilegesOfAccount(%p %p)\n",
583           AccountHandle, Privileges);
584 
585     RpcTryExcept
586     {
587         Status = LsarEnumeratePrivilegesAccount((LSAPR_HANDLE)AccountHandle,
588                                                 (LSAPR_PRIVILEGE_SET **)Privileges);
589     }
590     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
591     {
592         Status = I_RpcMapWin32Status(RpcExceptionCode());
593     }
594     RpcEndExcept;
595 
596     return Status;
597 }
598 
599 
600 /*
601  * @implemented
602  */
603 NTSTATUS
604 WINAPI
605 LsaEnumerateTrustedDomains(IN LSA_HANDLE PolicyHandle,
606                            IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext,
607                            OUT PVOID *Buffer,
608                            IN ULONG PreferedMaximumLength,
609                            OUT PULONG CountReturned)
610 {
611     LSAPR_TRUSTED_ENUM_BUFFER TrustedEnumBuffer;
612     NTSTATUS Status;
613 
614     TRACE("LsaEnumerateTrustedDomains(%p %p %p %lu %p)\n",
615           PolicyHandle, EnumerationContext, Buffer,
616           PreferedMaximumLength, CountReturned);
617 
618     if (Buffer == NULL)
619         return STATUS_INVALID_PARAMETER;
620 
621     TrustedEnumBuffer.EntriesRead = 0;
622     TrustedEnumBuffer.Information = NULL;
623 
624     RpcTryExcept
625     {
626         Status = LsarEnumerateTrustedDomains((LSAPR_HANDLE)PolicyHandle,
627                                              EnumerationContext,
628                                              &TrustedEnumBuffer,
629                                              PreferedMaximumLength);
630 
631         *Buffer = TrustedEnumBuffer.Information;
632         *CountReturned = TrustedEnumBuffer.EntriesRead;
633 
634     }
635     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
636     {
637         if (TrustedEnumBuffer.Information != NULL)
638             MIDL_user_free(TrustedEnumBuffer.Information);
639 
640         Status = I_RpcMapWin32Status(RpcExceptionCode());
641     }
642     RpcEndExcept;
643 
644     return Status;
645 }
646 
647 
648 /*
649  * @implemented
650  */
651 NTSTATUS
652 WINAPI
653 LsaEnumerateTrustedDomainsEx(IN LSA_HANDLE PolicyHandle,
654                              IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext,
655                              OUT PVOID *Buffer,
656                              IN ULONG PreferedMaximumLength,
657                              OUT PULONG CountReturned)
658 {
659     LSAPR_TRUSTED_ENUM_BUFFER_EX TrustedEnumBuffer;
660     NTSTATUS Status;
661 
662     TRACE("LsaEnumerateTrustedDomainsEx(%p %p %p %lu %p)\n",
663           PolicyHandle, EnumerationContext, Buffer,
664           PreferedMaximumLength, CountReturned);
665 
666     if (Buffer == NULL)
667         return STATUS_INVALID_PARAMETER;
668 
669     TrustedEnumBuffer.EntriesRead = 0;
670     TrustedEnumBuffer.EnumerationBuffer = NULL;
671 
672     RpcTryExcept
673     {
674         Status = LsarEnumerateTrustedDomainsEx((LSAPR_HANDLE)PolicyHandle,
675                                                EnumerationContext,
676                                                &TrustedEnumBuffer,
677                                                PreferedMaximumLength);
678 
679         *Buffer = TrustedEnumBuffer.EnumerationBuffer;
680         *CountReturned = TrustedEnumBuffer.EntriesRead;
681 
682     }
683     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
684     {
685         if (TrustedEnumBuffer.EnumerationBuffer != NULL)
686             MIDL_user_free(TrustedEnumBuffer.EnumerationBuffer);
687 
688         Status = I_RpcMapWin32Status(RpcExceptionCode());
689     }
690     RpcEndExcept;
691 
692     return Status;
693 }
694 
695 
696 /*
697  * @implemented
698  */
699 NTSTATUS
700 WINAPI
701 LsaFreeMemory(IN PVOID Buffer)
702 {
703     TRACE("LsaFreeMemory(%p)\n", Buffer);
704     return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
705 }
706 
707 
708 /*
709  * @implemented
710  */
711 NTSTATUS
712 WINAPI
713 LsaGetQuotasForAccount(IN LSA_HANDLE AccountHandle,
714                        OUT PQUOTA_LIMITS QuotaLimits)
715 {
716     NTSTATUS Status;
717 
718     TRACE("LsaGetQuotasForAccount(%p %p)\n",
719           AccountHandle, QuotaLimits);
720 
721     RpcTryExcept
722     {
723         Status = LsarGetQuotasForAccount((LSAPR_HANDLE)AccountHandle,
724                                          QuotaLimits);
725     }
726     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
727     {
728         Status = I_RpcMapWin32Status(RpcExceptionCode());
729     }
730     RpcEndExcept;
731 
732     return Status;
733 }
734 
735 
736 /*
737  * @implemented
738  */
739 NTSTATUS
740 WINAPI
741 LsaGetRemoteUserName(IN PLSA_UNICODE_STRING SystemName OPTIONAL,
742                      OUT PLSA_UNICODE_STRING *UserName,
743                      OUT PLSA_UNICODE_STRING *DomainName OPTIONAL)
744 {
745     PRPC_UNICODE_STRING UserNameString = NULL;
746     PRPC_UNICODE_STRING DomainNameString = NULL;
747     NTSTATUS Status;
748 
749     TRACE("LsaGetRemoteUserName(%s %p %p)\n",
750           SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
751           UserName, DomainName);
752 
753     RpcTryExcept
754     {
755         Status = LsarGetUserName((PLSAPR_SERVER_NAME)SystemName,
756                                  &UserNameString,
757                                  (DomainName != NULL) ? &DomainNameString : NULL);
758 
759         *UserName = (PLSA_UNICODE_STRING)UserNameString;
760 
761         if (DomainName != NULL)
762             *DomainName = (PLSA_UNICODE_STRING)DomainNameString;
763     }
764     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
765     {
766         if (UserNameString != NULL)
767             MIDL_user_free(UserNameString);
768 
769         if (DomainNameString != NULL)
770             MIDL_user_free(DomainNameString);
771 
772         Status = I_RpcMapWin32Status(RpcExceptionCode());
773     }
774     RpcEndExcept;
775 
776     return Status;
777 }
778 
779 
780 /*
781  * @implemented
782  */
783 NTSTATUS
784 WINAPI
785 LsaGetSystemAccessAccount(IN LSA_HANDLE AccountHandle,
786                           OUT PULONG SystemAccess)
787 {
788     NTSTATUS Status;
789 
790     TRACE("LsaGetSystemAccessAccount(%p %p)\n",
791           AccountHandle, SystemAccess);
792 
793     RpcTryExcept
794     {
795         Status = LsarGetSystemAccessAccount((LSAPR_HANDLE)AccountHandle,
796                                             (ACCESS_MASK *)SystemAccess);
797     }
798     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
799     {
800         Status = I_RpcMapWin32Status(RpcExceptionCode());
801     }
802     RpcEndExcept;
803 
804     return Status;
805 }
806 
807 
808 /*
809  * @implemented
810  */
811 NTSTATUS
812 WINAPI
813 LsaGetUserName(OUT PUNICODE_STRING *UserName,
814                OUT PUNICODE_STRING *DomainName OPTIONAL)
815 {
816     PRPC_UNICODE_STRING UserNameString = NULL;
817     PRPC_UNICODE_STRING DomainNameString = NULL;
818     NTSTATUS Status;
819 
820     TRACE("LsaGetUserName(%p %p)\n",
821           UserName, DomainName);
822 
823     RpcTryExcept
824     {
825         Status = LsarGetUserName(NULL,
826                                  &UserNameString,
827                                  (DomainName != NULL) ? &DomainNameString : NULL);
828 
829         *UserName = (PUNICODE_STRING)UserNameString;
830 
831         if (DomainName != NULL)
832             *DomainName = (PUNICODE_STRING)DomainNameString;
833     }
834     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
835     {
836         if (UserNameString != NULL)
837             MIDL_user_free(UserNameString);
838 
839         if (DomainNameString != NULL)
840             MIDL_user_free(DomainNameString);
841 
842         Status = I_RpcMapWin32Status(RpcExceptionCode());
843     }
844     RpcEndExcept;
845 
846     return Status;
847 }
848 
849 
850 /*
851  * @implemented
852  */
853 NTSTATUS
854 WINAPI
855 LsaLookupNames(IN LSA_HANDLE PolicyHandle,
856                IN ULONG Count,
857                IN PLSA_UNICODE_STRING Names,
858                OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
859                OUT PLSA_TRANSLATED_SID *Sids)
860 {
861     LSAPR_TRANSLATED_SIDS TranslatedSids = {0, NULL};
862     ULONG MappedCount = 0;
863     NTSTATUS Status;
864 
865     TRACE("LsaLookupNames(%p %lu %p %p %p)\n",
866           PolicyHandle, Count, Names, ReferencedDomains, Sids);
867 
868     if (ReferencedDomains == NULL || Sids == NULL)
869         return STATUS_INVALID_PARAMETER;
870 
871     RpcTryExcept
872     {
873         *ReferencedDomains = NULL;
874         *Sids = NULL;
875 
876         TranslatedSids.Entries = Count;
877 
878         Status = LsarLookupNames((LSAPR_HANDLE)PolicyHandle,
879                                  Count,
880                                  (PRPC_UNICODE_STRING)Names,
881                                  (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
882                                  &TranslatedSids,
883                                  LsapLookupWksta,
884                                  &MappedCount);
885 
886         *Sids = (PLSA_TRANSLATED_SID)TranslatedSids.Sids;
887     }
888     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
889     {
890         if (TranslatedSids.Sids != NULL)
891             MIDL_user_free(TranslatedSids.Sids);
892 
893         Status = I_RpcMapWin32Status(RpcExceptionCode());
894     }
895     RpcEndExcept;
896 
897     return Status;
898 }
899 
900 
901 /*
902  * @implemented
903  */
904 NTSTATUS
905 WINAPI
906 LsaLookupNames2(IN LSA_HANDLE PolicyHandle,
907                 IN ULONG Flags,
908                 IN ULONG Count,
909                 IN PLSA_UNICODE_STRING Names,
910                 OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
911                 OUT PLSA_TRANSLATED_SID2 *Sids)
912 {
913     LSAPR_TRANSLATED_SIDS_EX2 TranslatedSids = {0, NULL};
914     ULONG MappedCount = 0;
915     NTSTATUS Status;
916 
917     TRACE("LsaLookupNames2(%p 0x%08x %lu %p %p %p)\n",
918           PolicyHandle, Flags, Count, Names, ReferencedDomains, Sids);
919 
920     if (ReferencedDomains == NULL || Sids == NULL)
921         return STATUS_INVALID_PARAMETER;
922 
923     RpcTryExcept
924     {
925         *ReferencedDomains = NULL;
926         *Sids = NULL;
927 
928         TranslatedSids.Entries = Count;
929 
930         Status = LsarLookupNames3((LSAPR_HANDLE)PolicyHandle,
931                                   Count,
932                                   (PRPC_UNICODE_STRING)Names,
933                                   (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
934                                   &TranslatedSids,
935                                   LsapLookupWksta,
936                                   &MappedCount,
937                                   Flags,
938                                   2);
939 
940         *Sids = (PLSA_TRANSLATED_SID2)TranslatedSids.Sids;
941     }
942     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
943     {
944         if (TranslatedSids.Sids != NULL)
945             MIDL_user_free(TranslatedSids.Sids);
946 
947         Status = I_RpcMapWin32Status(RpcExceptionCode());
948     }
949     RpcEndExcept;
950 
951     return Status;
952 }
953 
954 
955 /*
956  * @implemented
957  */
958 NTSTATUS
959 WINAPI
960 LsaLookupPrivilegeDisplayName(IN LSA_HANDLE PolicyHandle,
961                               IN PLSA_UNICODE_STRING Name,
962                               OUT PLSA_UNICODE_STRING *DisplayName,
963                               OUT PUSHORT LanguageReturned)
964 {
965     PRPC_UNICODE_STRING DisplayNameBuffer = NULL;
966     NTSTATUS Status;
967 
968     TRACE("LsaLookupPrivilegeDisplayName(%p %p %p %p)\n",
969           PolicyHandle, Name, DisplayName, LanguageReturned);
970 
971     RpcTryExcept
972     {
973         Status = LsarLookupPrivilegeDisplayName(PolicyHandle,
974                                                 (PRPC_UNICODE_STRING)Name,
975                                                 GetUserDefaultUILanguage(),
976                                                 GetSystemDefaultUILanguage(),
977                                                 &DisplayNameBuffer,
978                                                 LanguageReturned);
979 
980         *DisplayName = (PUNICODE_STRING)DisplayNameBuffer;
981     }
982     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
983     {
984         if (DisplayNameBuffer != NULL)
985             MIDL_user_free(DisplayNameBuffer);
986 
987         Status = I_RpcMapWin32Status(RpcExceptionCode());
988     }
989     RpcEndExcept;
990 
991     return Status;
992 }
993 
994 
995 /*
996  * @implemented
997  */
998 NTSTATUS
999 WINAPI
1000 LsaLookupPrivilegeName(IN LSA_HANDLE PolicyHandle,
1001                        IN PLUID Value,
1002                        OUT PUNICODE_STRING *Name)
1003 {
1004     PRPC_UNICODE_STRING NameBuffer = NULL;
1005     NTSTATUS Status;
1006 
1007     TRACE("LsaLookupPrivilegeName(%p %p %p)\n",
1008           PolicyHandle, Value, Name);
1009 
1010     RpcTryExcept
1011     {
1012         Status = LsarLookupPrivilegeName(PolicyHandle,
1013                                          Value,
1014                                          &NameBuffer);
1015 
1016         *Name = (PUNICODE_STRING)NameBuffer;
1017     }
1018     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1019     {
1020         if (NameBuffer != NULL)
1021             MIDL_user_free(NameBuffer);
1022 
1023         Status = I_RpcMapWin32Status(RpcExceptionCode());
1024     }
1025     RpcEndExcept;
1026 
1027     return Status;
1028 }
1029 
1030 
1031 /*
1032  * @implemented
1033  */
1034 NTSTATUS
1035 WINAPI
1036 LsaLookupPrivilegeValue(IN LSA_HANDLE PolicyHandle,
1037                         IN PLSA_UNICODE_STRING Name,
1038                         OUT PLUID Value)
1039 {
1040     LUID Luid;
1041     NTSTATUS Status;
1042 
1043     TRACE("LsaLookupPrivilegeValue(%p %p %p)\n",
1044           PolicyHandle, Name, Value);
1045 
1046     RpcTryExcept
1047     {
1048         Status = LsarLookupPrivilegeValue(PolicyHandle,
1049                                           (PRPC_UNICODE_STRING)Name,
1050                                           &Luid);
1051         if (Status == STATUS_SUCCESS)
1052             *Value = Luid;
1053     }
1054     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1055     {
1056         Status = I_RpcMapWin32Status(RpcExceptionCode());
1057     }
1058     RpcEndExcept;
1059 
1060     return Status;
1061 }
1062 
1063 
1064 /*
1065  * @implemented
1066  */
1067 NTSTATUS
1068 WINAPI
1069 LsaLookupSids(IN LSA_HANDLE PolicyHandle,
1070               IN ULONG Count,
1071               IN PSID *Sids,
1072               OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1073               OUT PLSA_TRANSLATED_NAME *Names)
1074 {
1075     LSAPR_SID_ENUM_BUFFER SidEnumBuffer;
1076     LSAPR_TRANSLATED_NAMES TranslatedNames;
1077     ULONG MappedCount = 0;
1078     NTSTATUS  Status;
1079 
1080     TRACE("LsaLookupSids(%p %lu %p %p %p)\n",
1081           PolicyHandle, Count, Sids, ReferencedDomains, Names);
1082 
1083     if (Count == 0)
1084         return STATUS_INVALID_PARAMETER;
1085 
1086     SidEnumBuffer.Entries = Count;
1087     SidEnumBuffer.SidInfo = (PLSAPR_SID_INFORMATION)Sids;
1088 
1089     RpcTryExcept
1090     {
1091         *ReferencedDomains = NULL;
1092         *Names = NULL;
1093 
1094         TranslatedNames.Entries = 0;
1095         TranslatedNames.Names = NULL;
1096 
1097         Status = LsarLookupSids((LSAPR_HANDLE)PolicyHandle,
1098                                 &SidEnumBuffer,
1099                                 (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
1100                                 &TranslatedNames,
1101                                 LsapLookupWksta,
1102                                 &MappedCount);
1103 
1104         *Names = (PLSA_TRANSLATED_NAME)TranslatedNames.Names;
1105     }
1106     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1107     {
1108         if (TranslatedNames.Names != NULL)
1109         {
1110             MIDL_user_free(TranslatedNames.Names);
1111         }
1112 
1113         Status = I_RpcMapWin32Status(RpcExceptionCode());
1114     }
1115     RpcEndExcept;
1116 
1117     return Status;
1118 }
1119 
1120 
1121 /******************************************************************************
1122  * LsaNtStatusToWinError
1123  *
1124  * PARAMS
1125  *   Status [I]
1126  *
1127  * @implemented
1128  */
1129 ULONG
1130 WINAPI
1131 LsaNtStatusToWinError(IN NTSTATUS Status)
1132 {
1133     TRACE("LsaNtStatusToWinError(0x%lx)\n", Status);
1134     return RtlNtStatusToDosError(Status);
1135 }
1136 
1137 
1138 /*
1139  * @implemented
1140  */
1141 NTSTATUS
1142 WINAPI
1143 LsaOpenAccount(IN LSA_HANDLE PolicyHandle,
1144                IN PSID AccountSid,
1145                IN ACCESS_MASK DesiredAccess,
1146                OUT PLSA_HANDLE AccountHandle)
1147 {
1148     NTSTATUS Status;
1149 
1150     TRACE("LsaOpenAccount(%p %p 0x%08lx %p)\n",
1151           PolicyHandle, AccountSid, DesiredAccess, AccountHandle);
1152 
1153     RpcTryExcept
1154     {
1155         Status = LsarOpenAccount((LSAPR_HANDLE)PolicyHandle,
1156                                  AccountSid,
1157                                  DesiredAccess,
1158                                  AccountHandle);
1159     }
1160     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1161     {
1162         Status = I_RpcMapWin32Status(RpcExceptionCode());
1163     }
1164     RpcEndExcept;
1165 
1166     return Status;
1167 }
1168 
1169 
1170 /******************************************************************************
1171  * LsaOpenPolicy
1172  *
1173  * PARAMS
1174  *   x1 []
1175  *   x2 []
1176  *   x3 []
1177  *   x4 []
1178  *
1179  * @implemented
1180  */
1181 NTSTATUS
1182 WINAPI
1183 LsaOpenPolicy(IN PLSA_UNICODE_STRING SystemName OPTIONAL,
1184               IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
1185               IN ACCESS_MASK DesiredAccess,
1186               OUT PLSA_HANDLE PolicyHandle)
1187 {
1188     NTSTATUS Status;
1189 
1190     TRACE("LsaOpenPolicy(%s %p 0x%08lx %p)\n",
1191           SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
1192           ObjectAttributes, DesiredAccess, PolicyHandle);
1193 
1194     /* FIXME: RPC should take care of this */
1195     if (!LsapIsLocalComputer(SystemName))
1196         return RPC_NT_SERVER_UNAVAILABLE;
1197 
1198     RpcTryExcept
1199     {
1200         *PolicyHandle = NULL;
1201 
1202         Status = LsarOpenPolicy(SystemName ? SystemName->Buffer : NULL,
1203                                 (PLSAPR_OBJECT_ATTRIBUTES)ObjectAttributes,
1204                                 DesiredAccess,
1205                                 PolicyHandle);
1206     }
1207     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1208     {
1209         Status = I_RpcMapWin32Status(RpcExceptionCode());
1210     }
1211     RpcEndExcept;
1212 
1213     TRACE("LsaOpenPolicy() done (Status: 0x%08lx)\n", Status);
1214 
1215     return Status;
1216 }
1217 
1218 
1219 /*
1220  * @implemented
1221  */
1222 NTSTATUS
1223 WINAPI
1224 LsaOpenPolicySce(IN PLSA_UNICODE_STRING SystemName OPTIONAL,
1225                  IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
1226                  IN ACCESS_MASK DesiredAccess,
1227                  OUT PLSA_HANDLE PolicyHandle)
1228 {
1229     NTSTATUS Status;
1230 
1231     TRACE("LsaOpenPolicySce(%s %p 0x%08lx %p)\n",
1232           SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
1233           ObjectAttributes, DesiredAccess, PolicyHandle);
1234 
1235     /* FIXME: RPC should take care of this */
1236     if (!LsapIsLocalComputer(SystemName))
1237         return RPC_NT_SERVER_UNAVAILABLE;
1238 
1239     RpcTryExcept
1240     {
1241         *PolicyHandle = NULL;
1242 
1243         Status = LsarOpenPolicySce(SystemName ? SystemName->Buffer : NULL,
1244                                    (PLSAPR_OBJECT_ATTRIBUTES)ObjectAttributes,
1245                                    DesiredAccess,
1246                                    PolicyHandle);
1247     }
1248     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1249     {
1250         Status = I_RpcMapWin32Status(RpcExceptionCode());
1251     }
1252     RpcEndExcept;
1253 
1254     TRACE("LsaOpenPolicySce() done (Status: 0x%08lx)\n", Status);
1255 
1256     return Status;
1257 }
1258 
1259 
1260 /*
1261  * @implemented
1262  */
1263 NTSTATUS
1264 WINAPI
1265 LsaOpenSecret(IN LSA_HANDLE PolicyHandle,
1266               IN PLSA_UNICODE_STRING SecretName,
1267               IN ACCESS_MASK DesiredAccess,
1268               OUT PLSA_HANDLE SecretHandle)
1269 {
1270     NTSTATUS Status;
1271 
1272     TRACE("LsaOpenSecret(%p %p 0x%08lx %p)\n",
1273           PolicyHandle, SecretName, DesiredAccess, SecretHandle);
1274 
1275     RpcTryExcept
1276     {
1277         *SecretHandle = NULL;
1278 
1279         Status = LsarOpenSecret((LSAPR_HANDLE)PolicyHandle,
1280                                 (PRPC_UNICODE_STRING)SecretName,
1281                                 DesiredAccess,
1282                                 SecretHandle);
1283     }
1284     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1285     {
1286         Status = I_RpcMapWin32Status(RpcExceptionCode());
1287     }
1288     RpcEndExcept;
1289 
1290     TRACE("LsaOpenSecret() done (Status: 0x%08lx)\n", Status);
1291 
1292     return Status;
1293 }
1294 
1295 
1296 /*
1297  * @implemented
1298  */
1299 NTSTATUS
1300 WINAPI
1301 LsaOpenTrustedDomain(IN LSA_HANDLE PolicyHandle,
1302                      IN PSID TrustedDomainSid,
1303                      IN ACCESS_MASK DesiredAccess,
1304                      OUT PLSA_HANDLE TrustedDomainHandle)
1305 {
1306     NTSTATUS Status;
1307 
1308     TRACE("LsaOpenTrustedDomain(%p %p 0x%08lx %p)\n",
1309           PolicyHandle, TrustedDomainSid, DesiredAccess, TrustedDomainHandle);
1310 
1311     RpcTryExcept
1312     {
1313         Status = LsarOpenTrustedDomain((LSAPR_HANDLE)PolicyHandle,
1314                                        (PRPC_SID)TrustedDomainSid,
1315                                        DesiredAccess,
1316                                        (PLSAPR_HANDLE)TrustedDomainHandle);
1317     }
1318     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1319     {
1320         Status = I_RpcMapWin32Status(RpcExceptionCode());
1321     }
1322     RpcEndExcept;
1323 
1324     return Status;
1325 }
1326 
1327 
1328 /*
1329  * @implemented
1330  */
1331 NTSTATUS
1332 WINAPI
1333 LsaOpenTrustedDomainByName(IN LSA_HANDLE PolicyHandle,
1334                            IN PLSA_UNICODE_STRING TrustedDomainName,
1335                            IN ACCESS_MASK DesiredAccess,
1336                            OUT PLSA_HANDLE TrustedDomainHandle)
1337 {
1338     NTSTATUS Status;
1339 
1340     TRACE("LsaOpenTrustedDomainByName(%p %p 0x%08lx %p)\n",
1341           PolicyHandle, TrustedDomainName, DesiredAccess, TrustedDomainHandle);
1342 
1343     RpcTryExcept
1344     {
1345         Status = LsarOpenTrustedDomainByName((LSAPR_HANDLE)PolicyHandle,
1346                                              (PRPC_UNICODE_STRING)TrustedDomainName,
1347                                              DesiredAccess,
1348                                              TrustedDomainHandle);
1349     }
1350     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1351     {
1352         Status = I_RpcMapWin32Status(RpcExceptionCode());
1353     }
1354     RpcEndExcept;
1355 
1356     return Status;
1357 }
1358 
1359 
1360 /*
1361  * @implemented
1362  */
1363 NTSTATUS
1364 WINAPI
1365 LsaQueryDomainInformationPolicy(IN LSA_HANDLE PolicyHandle,
1366                                 IN POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
1367                                 OUT PVOID *Buffer)
1368 {
1369     PLSAPR_POLICY_DOMAIN_INFORMATION PolicyInformation = NULL;
1370     NTSTATUS Status;
1371 
1372     TRACE("LsaQueryDomainInformationPolicy(%p %lu %p)\n",
1373           PolicyHandle, InformationClass, Buffer);
1374 
1375     RpcTryExcept
1376     {
1377         Status = LsarQueryDomainInformationPolicy((LSAPR_HANDLE)PolicyHandle,
1378                                                   InformationClass,
1379                                                   &PolicyInformation);
1380 
1381         *Buffer = PolicyInformation;
1382     }
1383     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1384     {
1385         if (PolicyInformation != NULL)
1386             MIDL_user_free(PolicyInformation);
1387 
1388         Status = I_RpcMapWin32Status(RpcExceptionCode());
1389     }
1390     RpcEndExcept;
1391 
1392     return Status;
1393 }
1394 
1395 
1396 /*
1397  * @implemented
1398  */
1399 NTSTATUS
1400 WINAPI
1401 LsaQueryForestTrustInformation(IN LSA_HANDLE PolicyHandle,
1402                                IN PLSA_UNICODE_STRING TrustedDomainName,
1403                                OUT PLSA_FOREST_TRUST_INFORMATION *ForestTrustInfo)
1404 {
1405     NTSTATUS Status;
1406 
1407     TRACE("LsaQueryForestTrustInformation(%p %p %p)\n",
1408           PolicyHandle, TrustedDomainName, ForestTrustInfo);
1409 
1410     RpcTryExcept
1411     {
1412         Status = LsarQueryForestTrustInformation((LSAPR_HANDLE)PolicyHandle,
1413                                                  TrustedDomainName,
1414                                                  ForestTrustDomainInfo,
1415                                                  ForestTrustInfo);
1416     }
1417     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1418     {
1419         Status = I_RpcMapWin32Status(RpcExceptionCode());
1420     }
1421     RpcEndExcept;
1422 
1423     return Status;
1424 }
1425 
1426 
1427 /*
1428  * @implemented
1429  */
1430 NTSTATUS
1431 WINAPI
1432 LsaQueryInfoTrustedDomain(IN LSA_HANDLE TrustedDomainHandle,
1433                           IN TRUSTED_INFORMATION_CLASS InformationClass,
1434                           OUT PVOID *Buffer)
1435 {
1436     PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation = NULL;
1437     NTSTATUS Status;
1438 
1439     TRACE("LsaQueryInfoTrustedDomain(%p %d %p) stub\n",
1440           TrustedDomainHandle, InformationClass, Buffer);
1441 
1442     if (InformationClass == TrustedDomainAuthInformationInternal ||
1443         InformationClass == TrustedDomainFullInformationInternal)
1444         return STATUS_INVALID_INFO_CLASS;
1445 
1446     RpcTryExcept
1447     {
1448         Status = LsarQueryInfoTrustedDomain((LSAPR_HANDLE)TrustedDomainHandle,
1449                                             InformationClass,
1450                                             &TrustedDomainInformation);
1451         *Buffer = TrustedDomainInformation;
1452     }
1453     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1454     {
1455         if (TrustedDomainInformation != NULL)
1456             MIDL_user_free(TrustedDomainInformation);
1457 
1458         Status = I_RpcMapWin32Status(RpcExceptionCode());
1459     }
1460     RpcEndExcept;
1461 
1462     TRACE("Done (Status: 0x%08x)\n", Status);
1463 
1464     return Status;
1465 }
1466 
1467 
1468 /*
1469  * @implemented
1470  */
1471 NTSTATUS
1472 WINAPI
1473 LsaQueryInformationPolicy(IN LSA_HANDLE PolicyHandle,
1474                           IN POLICY_INFORMATION_CLASS InformationClass,
1475                           OUT PVOID *Buffer)
1476 {
1477     PLSAPR_POLICY_INFORMATION PolicyInformation = NULL;
1478     NTSTATUS Status;
1479 
1480     TRACE("LsaQueryInformationPolicy(%p %d %p)\n",
1481           PolicyHandle, InformationClass, Buffer);
1482 
1483     RpcTryExcept
1484     {
1485         Status = LsarQueryInformationPolicy((LSAPR_HANDLE)PolicyHandle,
1486                                             InformationClass,
1487                                             &PolicyInformation);
1488         *Buffer = PolicyInformation;
1489     }
1490     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1491     {
1492         if (PolicyInformation != NULL)
1493             MIDL_user_free(PolicyInformation);
1494 
1495         Status = I_RpcMapWin32Status(RpcExceptionCode());
1496     }
1497     RpcEndExcept;
1498 
1499     TRACE("Done (Status: 0x%08x)\n", Status);
1500 
1501     return Status;
1502 }
1503 
1504 
1505 /*
1506  * @implemented
1507  */
1508 NTSTATUS
1509 WINAPI
1510 LsaQuerySecret(IN LSA_HANDLE SecretHandle,
1511                OUT PLSA_UNICODE_STRING *CurrentValue OPTIONAL,
1512                OUT PLARGE_INTEGER CurrentValueSetTime OPTIONAL,
1513                OUT PLSA_UNICODE_STRING *OldValue OPTIONAL,
1514                OUT PLARGE_INTEGER OldValueSetTime OPTIONAL)
1515 {
1516     PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue = NULL;
1517     PLSAPR_CR_CIPHER_VALUE EncryptedOldValue = NULL;
1518     PLSA_UNICODE_STRING DecryptedCurrentValue = NULL;
1519     PLSA_UNICODE_STRING DecryptedOldValue = NULL;
1520     SIZE_T BufferSize;
1521     NTSTATUS Status;
1522 
1523     TRACE("LsaQuerySecret(%p %p %p %p %p)\n",
1524           SecretHandle, CurrentValue, CurrentValueSetTime,
1525           OldValue, OldValueSetTime);
1526 
1527     RpcTryExcept
1528     {
1529         Status = LsarQuerySecret((PLSAPR_HANDLE)SecretHandle,
1530                                  &EncryptedCurrentValue,
1531                                  CurrentValueSetTime,
1532                                  &EncryptedOldValue,
1533                                  OldValueSetTime);
1534     }
1535     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1536     {
1537         Status = I_RpcMapWin32Status(RpcExceptionCode());
1538     }
1539     RpcEndExcept;
1540 
1541     if (!NT_SUCCESS(Status))
1542         goto done;
1543 
1544     /* Decrypt the current value */
1545     if (CurrentValue != NULL)
1546     {
1547          if (EncryptedCurrentValue == NULL)
1548          {
1549              *CurrentValue = NULL;
1550          }
1551          else
1552          {
1553              /* FIXME: Decrypt the current value */
1554              BufferSize = sizeof(LSA_UNICODE_STRING) + EncryptedCurrentValue->MaximumLength;
1555              DecryptedCurrentValue = midl_user_allocate(BufferSize);
1556              if (DecryptedCurrentValue == NULL)
1557              {
1558                  Status = STATUS_INSUFFICIENT_RESOURCES;
1559                  goto done;
1560              }
1561 
1562              DecryptedCurrentValue->Length = (USHORT)EncryptedCurrentValue->Length;
1563              DecryptedCurrentValue->MaximumLength = (USHORT)EncryptedCurrentValue->MaximumLength;
1564              DecryptedCurrentValue->Buffer = (PWSTR)(DecryptedCurrentValue + 1);
1565              RtlCopyMemory(DecryptedCurrentValue->Buffer,
1566                            EncryptedCurrentValue->Buffer,
1567                            EncryptedCurrentValue->Length);
1568 
1569              *CurrentValue = DecryptedCurrentValue;
1570          }
1571     }
1572 
1573     /* Decrypt the old value */
1574     if (OldValue != NULL)
1575     {
1576          if (EncryptedOldValue == NULL)
1577          {
1578              *OldValue = NULL;
1579          }
1580          else
1581          {
1582              /* FIXME: Decrypt the old value */
1583              BufferSize = sizeof(LSA_UNICODE_STRING) + EncryptedOldValue->MaximumLength;
1584              DecryptedOldValue = midl_user_allocate(BufferSize);
1585              if (DecryptedOldValue == NULL)
1586              {
1587                  Status = STATUS_INSUFFICIENT_RESOURCES;
1588                  goto done;
1589              }
1590 
1591              DecryptedOldValue->Length = (USHORT)EncryptedOldValue->Length;
1592              DecryptedOldValue->MaximumLength = (USHORT)EncryptedOldValue->MaximumLength;
1593              DecryptedOldValue->Buffer = (PWSTR)(DecryptedOldValue + 1);
1594              RtlCopyMemory(DecryptedOldValue->Buffer,
1595                            EncryptedOldValue->Buffer,
1596                            EncryptedOldValue->Length);
1597 
1598              *OldValue = DecryptedOldValue;
1599          }
1600     }
1601 
1602 done:
1603     if (!NT_SUCCESS(Status))
1604     {
1605         if (DecryptedCurrentValue != NULL)
1606             midl_user_free(DecryptedCurrentValue);
1607 
1608         if (DecryptedOldValue != NULL)
1609             midl_user_free(DecryptedOldValue);
1610 
1611         if (CurrentValue != NULL)
1612             *CurrentValue = NULL;
1613 
1614         if (OldValue != NULL)
1615             *OldValue = NULL;
1616     }
1617 
1618     if (EncryptedCurrentValue != NULL)
1619         midl_user_free(EncryptedCurrentValue);
1620 
1621     if (EncryptedOldValue != NULL)
1622         midl_user_free(EncryptedOldValue);
1623 
1624     return Status;
1625 }
1626 
1627 
1628 /*
1629  * @implemented
1630  */
1631 NTSTATUS
1632 WINAPI
1633 LsaQuerySecurityObject(IN LSA_HANDLE ObjectHandle,
1634                        IN SECURITY_INFORMATION SecurityInformation,
1635                        OUT PSECURITY_DESCRIPTOR *SecurityDescriptor)
1636 {
1637     LSAPR_SR_SECURITY_DESCRIPTOR SdBuffer;
1638     PLSAPR_SR_SECURITY_DESCRIPTOR SdPointer;
1639     NTSTATUS Status;
1640 
1641     TRACE("LsaQuerySecurityObject(%p %lx %p)\n",
1642           ObjectHandle, SecurityInformation, SecurityDescriptor);
1643 
1644     SdBuffer.Length = 0;
1645     SdBuffer.SecurityDescriptor = NULL;
1646 
1647     SdPointer = &SdBuffer;
1648 
1649     RpcTryExcept
1650     {
1651         Status = LsarQuerySecurityObject((LSAPR_HANDLE)ObjectHandle,
1652                                          SecurityInformation,
1653                                          &SdPointer);
1654         if (NT_SUCCESS(Status))
1655         {
1656             *SecurityDescriptor = SdBuffer.SecurityDescriptor;
1657         }
1658         else
1659         {
1660             *SecurityDescriptor = NULL;
1661         }
1662     }
1663     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1664     {
1665         Status = I_RpcMapWin32Status(RpcExceptionCode());
1666     }
1667     RpcEndExcept;
1668 
1669     return Status;
1670 }
1671 
1672 
1673 /*
1674  * @implemented
1675  */
1676 NTSTATUS
1677 WINAPI
1678 LsaQueryTrustedDomainInfo(IN LSA_HANDLE PolicyHandle,
1679                           IN PSID TrustedDomainSid,
1680                           IN TRUSTED_INFORMATION_CLASS InformationClass,
1681                           OUT PVOID *Buffer)
1682 {
1683     NTSTATUS Status;
1684 
1685     TRACE("LsaQueryTrustedDomainInfo(%p %p %d %p) stub\n",
1686           PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
1687 
1688     if (InformationClass == TrustedDomainAuthInformationInternal ||
1689         InformationClass == TrustedDomainFullInformationInternal)
1690         return STATUS_INVALID_INFO_CLASS;
1691 
1692     RpcTryExcept
1693     {
1694         Status = LsarQueryTrustedDomainInfo((LSAPR_HANDLE)PolicyHandle,
1695                                             (PRPC_SID)TrustedDomainSid,
1696                                             InformationClass,
1697                                             (PLSAPR_TRUSTED_DOMAIN_INFO *)Buffer);
1698     }
1699     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1700     {
1701         Status = I_RpcMapWin32Status(RpcExceptionCode());
1702     }
1703     RpcEndExcept;
1704 
1705     return Status;
1706 }
1707 
1708 
1709 /*
1710  * @implemented
1711  */
1712 NTSTATUS
1713 WINAPI
1714 LsaQueryTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle,
1715                                 IN PLSA_UNICODE_STRING TrustedDomainName,
1716                                 IN TRUSTED_INFORMATION_CLASS InformationClass,
1717                                 OUT PVOID *Buffer)
1718 {
1719     NTSTATUS Status;
1720 
1721     TRACE("LsaQueryTrustedDomainInfoByName(%p %p %d %p)\n",
1722           PolicyHandle, TrustedDomainName, InformationClass, Buffer);
1723 
1724     if (InformationClass == TrustedDomainAuthInformationInternal ||
1725         InformationClass == TrustedDomainFullInformationInternal)
1726         return STATUS_INVALID_INFO_CLASS;
1727 
1728     RpcTryExcept
1729     {
1730         Status = LsarQueryTrustedDomainInfoByName((LSAPR_HANDLE)PolicyHandle,
1731                                                   (PRPC_UNICODE_STRING)TrustedDomainName,
1732                                                   InformationClass,
1733                                                   (PLSAPR_TRUSTED_DOMAIN_INFO *)Buffer);
1734     }
1735     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1736     {
1737         Status = I_RpcMapWin32Status(RpcExceptionCode());
1738     }
1739     RpcEndExcept;
1740 
1741     return Status;
1742 }
1743 
1744 
1745 /*
1746  * @implemented
1747  */
1748 NTSTATUS
1749 WINAPI
1750 LsaRemoveAccountRights(IN LSA_HANDLE PolicyHandle,
1751                        IN PSID AccountSid,
1752                        IN BOOLEAN AllRights,
1753                        IN PLSA_UNICODE_STRING UserRights,
1754                        IN ULONG CountOfRights)
1755 {
1756     NTSTATUS Status;
1757     LSAPR_USER_RIGHT_SET UserRightSet;
1758 
1759     TRACE("LsaRemoveAccountRights(%p %p %d %p %lu)\n",
1760           PolicyHandle, AccountSid, AllRights, UserRights, CountOfRights);
1761 
1762     UserRightSet.Entries = CountOfRights;
1763     UserRightSet.UserRights = (PRPC_UNICODE_STRING)UserRights;
1764 
1765     RpcTryExcept
1766     {
1767         Status = LsarRemoveAccountRights((LSAPR_HANDLE)PolicyHandle,
1768                                          (PRPC_SID)AccountSid,
1769                                          AllRights,
1770                                          &UserRightSet);
1771     }
1772     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1773     {
1774         Status = I_RpcMapWin32Status(RpcExceptionCode());
1775     }
1776     RpcEndExcept;
1777 
1778     return Status;
1779 }
1780 
1781 
1782 /*
1783  * @implemented
1784  */
1785 NTSTATUS
1786 WINAPI
1787 LsaRemovePrivilegesFromAccount(IN LSA_HANDLE AccountHandle,
1788                                IN BOOLEAN AllPrivileges,
1789                                IN PPRIVILEGE_SET Privileges OPTIONAL)
1790 {
1791     NTSTATUS Status;
1792 
1793     RpcTryExcept
1794     {
1795         Status = LsarRemovePrivilegesFromAccount((LSAPR_HANDLE)AccountHandle,
1796                                                  AllPrivileges,
1797                                                  (PLSAPR_PRIVILEGE_SET)Privileges);
1798     }
1799     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1800     {
1801         Status = I_RpcMapWin32Status(RpcExceptionCode());
1802     }
1803     RpcEndExcept;
1804 
1805     return Status;
1806 }
1807 
1808 
1809 /*
1810  * @implemented
1811  */
1812 NTSTATUS
1813 WINAPI
1814 LsaRetrievePrivateData(IN LSA_HANDLE PolicyHandle,
1815                        IN PLSA_UNICODE_STRING KeyName,
1816                        OUT PLSA_UNICODE_STRING *PrivateData)
1817 {
1818     PLSAPR_CR_CIPHER_VALUE EncryptedData = NULL;
1819     PLSA_UNICODE_STRING DecryptedData = NULL;
1820     SIZE_T BufferSize;
1821     NTSTATUS Status;
1822 
1823     TRACE("LsaRetrievePrivateData(%p %p %p)\n",
1824           PolicyHandle, KeyName, PrivateData);
1825 
1826     RpcTryExcept
1827     {
1828         Status = LsarRetrievePrivateData((LSAPR_HANDLE)PolicyHandle,
1829                                          (PRPC_UNICODE_STRING)KeyName,
1830                                          &EncryptedData);
1831     }
1832     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1833     {
1834         Status = I_RpcMapWin32Status(RpcExceptionCode());
1835     }
1836     RpcEndExcept;
1837 
1838     if (EncryptedData == NULL)
1839     {
1840         *PrivateData = NULL;
1841     }
1842     else
1843     {
1844         BufferSize = sizeof(LSA_UNICODE_STRING) + EncryptedData->MaximumLength;
1845         DecryptedData = midl_user_allocate(BufferSize);
1846         if (DecryptedData == NULL)
1847         {
1848             Status = STATUS_INSUFFICIENT_RESOURCES;
1849             goto done;
1850         }
1851 
1852         DecryptedData->Length = (USHORT)EncryptedData->Length;
1853         DecryptedData->MaximumLength = (USHORT)EncryptedData->MaximumLength;
1854         DecryptedData->Buffer = (PWSTR)(DecryptedData + 1);
1855         RtlCopyMemory(DecryptedData->Buffer,
1856                       EncryptedData->Buffer,
1857                       EncryptedData->Length);
1858 
1859         *PrivateData = DecryptedData;
1860     }
1861 
1862 done:
1863     if (!NT_SUCCESS(Status))
1864     {
1865         if (DecryptedData != NULL)
1866             midl_user_free(DecryptedData);
1867 
1868         *PrivateData = NULL;
1869     }
1870 
1871     if (EncryptedData != NULL)
1872         midl_user_free(EncryptedData);
1873 
1874     return Status;
1875 }
1876 
1877 
1878 /*
1879  * @implemented
1880  */
1881 NTSTATUS
1882 WINAPI
1883 LsaSetDomainInformationPolicy(IN LSA_HANDLE PolicyHandle,
1884                               IN POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
1885                               IN PVOID Buffer OPTIONAL)
1886 {
1887     NTSTATUS Status;
1888 
1889     TRACE("LsaSetDomainInformationPolicy(%p %d %p)\n",
1890           PolicyHandle, InformationClass, Buffer);
1891 
1892     RpcTryExcept
1893     {
1894         Status = LsarSetDomainInformationPolicy((LSAPR_HANDLE)PolicyHandle,
1895                                                 InformationClass,
1896                                                 (PLSAPR_POLICY_DOMAIN_INFORMATION)Buffer);
1897     }
1898     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1899     {
1900         Status = I_RpcMapWin32Status(RpcExceptionCode());
1901     }
1902     RpcEndExcept;
1903 
1904     return Status;
1905 }
1906 
1907 
1908 /*
1909  * @implemented
1910  */
1911 NTSTATUS
1912 WINAPI
1913 LsaSetForestTrustInformation(IN LSA_HANDLE PolicyHandle,
1914                              IN PLSA_UNICODE_STRING TrustedDomainName,
1915                              IN PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
1916                              IN BOOLEAN CheckOnly,
1917                              OUT PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
1918 {
1919     NTSTATUS Status;
1920 
1921     TRACE("LsaSetForestTrustInformation(%p %p %p %d %p)\n",
1922           PolicyHandle, TrustedDomainName, ForestTrustInfo, CheckOnly, CollisionInfo);
1923 
1924     RpcTryExcept
1925     {
1926         Status = LsarSetForestTrustInformation((LSAPR_HANDLE)PolicyHandle,
1927                                                TrustedDomainName,
1928                                                ForestTrustDomainInfo,
1929                                                ForestTrustInfo,
1930                                                CheckOnly,
1931                                                CollisionInfo);
1932     }
1933     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1934     {
1935         Status = I_RpcMapWin32Status(RpcExceptionCode());
1936     }
1937     RpcEndExcept;
1938 
1939     return Status;
1940 }
1941 
1942 
1943 /*
1944  * @implemented
1945  */
1946 NTSTATUS
1947 WINAPI
1948 LsaSetInformationPolicy(IN LSA_HANDLE PolicyHandle,
1949                         IN POLICY_INFORMATION_CLASS InformationClass,
1950                         IN PVOID Buffer)
1951 {
1952     NTSTATUS Status;
1953 
1954     TRACE("LsaSetInformationPolicy(%p %d %p)\n",
1955           PolicyHandle, InformationClass, Buffer);
1956 
1957     RpcTryExcept
1958     {
1959         Status = LsarSetInformationPolicy((LSAPR_HANDLE)PolicyHandle,
1960                                           InformationClass,
1961                                           (PLSAPR_POLICY_INFORMATION)Buffer);
1962     }
1963     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1964     {
1965         Status = I_RpcMapWin32Status(RpcExceptionCode());
1966     }
1967     RpcEndExcept;
1968 
1969     return Status;
1970 }
1971 
1972 
1973 /*
1974  * @unimplemented
1975  */
1976 NTSTATUS
1977 WINAPI
1978 LsaSetInformationTrustedDomain(IN LSA_HANDLE TrustedDomainHandle,
1979                                IN TRUSTED_INFORMATION_CLASS InformationClass,
1980                                IN PVOID Buffer)
1981 {
1982     FIXME("LsaSetInformationTrustedDomain(%p %d %p)\n",
1983           TrustedDomainHandle, InformationClass, Buffer);
1984     return STATUS_NOT_IMPLEMENTED;
1985 }
1986 
1987 
1988 /*
1989  * @implemented
1990  */
1991 NTSTATUS
1992 WINAPI
1993 LsaSetQuotasForAccount(IN LSA_HANDLE AccountHandle,
1994                        IN PQUOTA_LIMITS QuotaLimits)
1995 {
1996     NTSTATUS Status;
1997 
1998     TRACE("LsaSetQuotasForAccount(%p %p)\n",
1999           AccountHandle, QuotaLimits);
2000 
2001     RpcTryExcept
2002     {
2003         Status = LsarSetQuotasForAccount((LSAPR_HANDLE)AccountHandle,
2004                                          QuotaLimits);
2005     }
2006     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2007     {
2008         Status = I_RpcMapWin32Status(RpcExceptionCode());
2009     }
2010     RpcEndExcept;
2011 
2012     return Status;
2013 }
2014 
2015 
2016 /*
2017  * @implemented
2018  */
2019 NTSTATUS
2020 WINAPI
2021 LsaSetSecret(IN LSA_HANDLE SecretHandle,
2022              IN PLSA_UNICODE_STRING CurrentValue OPTIONAL,
2023              IN PLSA_UNICODE_STRING OldValue OPTIONAL)
2024 {
2025     PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue = NULL;
2026     PLSAPR_CR_CIPHER_VALUE EncryptedOldValue = NULL;
2027     SIZE_T BufferSize;
2028     NTSTATUS Status;
2029 
2030     TRACE("LsaSetSecret(%p %p %p)\n",
2031           SecretHandle, EncryptedCurrentValue, EncryptedOldValue);
2032 
2033     if (CurrentValue != NULL)
2034     {
2035         BufferSize = sizeof(LSAPR_CR_CIPHER_VALUE) + CurrentValue->MaximumLength;
2036         EncryptedCurrentValue = midl_user_allocate(BufferSize);
2037         if (EncryptedCurrentValue == NULL)
2038         {
2039             Status = STATUS_INSUFFICIENT_RESOURCES;
2040             goto done;
2041         }
2042 
2043         EncryptedCurrentValue->Length = CurrentValue->Length;
2044         EncryptedCurrentValue->MaximumLength = CurrentValue->MaximumLength;
2045         EncryptedCurrentValue->Buffer = (BYTE *)(EncryptedCurrentValue + 1);
2046         if (EncryptedCurrentValue->Buffer != NULL)
2047             memcpy(EncryptedCurrentValue->Buffer, CurrentValue->Buffer, CurrentValue->Length);
2048     }
2049 
2050     if (OldValue != NULL)
2051     {
2052         BufferSize = sizeof(LSAPR_CR_CIPHER_VALUE) + OldValue->MaximumLength;
2053         EncryptedOldValue = midl_user_allocate(BufferSize);
2054         if (EncryptedOldValue == NULL)
2055         {
2056             Status = STATUS_INSUFFICIENT_RESOURCES;
2057             goto done;
2058         }
2059 
2060         EncryptedOldValue->Length = OldValue->Length;
2061         EncryptedOldValue->MaximumLength = OldValue->MaximumLength;
2062         EncryptedOldValue->Buffer = (BYTE*)(EncryptedOldValue + 1);
2063         if (EncryptedOldValue->Buffer != NULL)
2064             memcpy(EncryptedOldValue->Buffer, OldValue->Buffer, OldValue->Length);
2065     }
2066 
2067     RpcTryExcept
2068     {
2069         Status = LsarSetSecret((LSAPR_HANDLE)SecretHandle,
2070                                EncryptedCurrentValue,
2071                                EncryptedOldValue);
2072     }
2073     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2074     {
2075         Status = I_RpcMapWin32Status(RpcExceptionCode());
2076     }
2077     RpcEndExcept;
2078 
2079 done:
2080     if (EncryptedCurrentValue != NULL)
2081         midl_user_free(EncryptedCurrentValue);
2082 
2083     if (EncryptedOldValue != NULL)
2084         midl_user_free(EncryptedOldValue);
2085 
2086     return Status;
2087 }
2088 
2089 
2090 /*
2091  * @implemented
2092  */
2093 NTSTATUS
2094 WINAPI
2095 LsaSetSecurityObject(IN LSA_HANDLE ObjectHandle,
2096                      IN SECURITY_INFORMATION SecurityInformation,
2097                      IN PSECURITY_DESCRIPTOR SecurityDescriptor)
2098 {
2099     LSAPR_SR_SECURITY_DESCRIPTOR SdBuffer = {0, NULL};
2100     ULONG SdLength = 0;
2101     NTSTATUS Status;
2102 
2103     TRACE("LsaSetSecurityObject(%p %lx %p)\n",
2104           ObjectHandle, SecurityInformation, SecurityDescriptor);
2105 
2106     Status = RtlMakeSelfRelativeSD(SecurityDescriptor,
2107                                    NULL,
2108                                    &SdLength);
2109     if (Status != STATUS_BUFFER_TOO_SMALL)
2110         return STATUS_INVALID_PARAMETER;
2111 
2112     SdBuffer.SecurityDescriptor = MIDL_user_allocate(SdLength);
2113     if (SdBuffer.SecurityDescriptor == NULL)
2114         return STATUS_INSUFFICIENT_RESOURCES;
2115 
2116     Status = RtlMakeSelfRelativeSD(SecurityDescriptor,
2117                                    (PSECURITY_DESCRIPTOR)SdBuffer.SecurityDescriptor,
2118                                    &SdLength);
2119     if (!NT_SUCCESS(Status))
2120         goto done;
2121 
2122     SdBuffer.Length = SdLength;
2123 
2124     RpcTryExcept
2125     {
2126         Status = LsarSetSecurityObject((LSAPR_HANDLE)ObjectHandle,
2127                                        SecurityInformation,
2128                                        &SdBuffer);
2129     }
2130     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2131     {
2132         Status = I_RpcMapWin32Status(RpcExceptionCode());
2133     }
2134     RpcEndExcept;
2135 
2136 done:
2137     if (SdBuffer.SecurityDescriptor != NULL)
2138         MIDL_user_free(SdBuffer.SecurityDescriptor);
2139 
2140     return Status;
2141 }
2142 
2143 
2144 /*
2145  * @implemented
2146  */
2147 NTSTATUS
2148 WINAPI
2149 LsaSetSystemAccessAccount(IN LSA_HANDLE AccountHandle,
2150                           IN ULONG SystemAccess)
2151 {
2152     NTSTATUS Status;
2153 
2154     TRACE("LsaSetSystemAccessAccount(%p 0x%lx)\n",
2155           AccountHandle, SystemAccess);
2156 
2157     RpcTryExcept
2158     {
2159         Status = LsarSetSystemAccessAccount((LSAPR_HANDLE)AccountHandle,
2160                                             SystemAccess);
2161     }
2162     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2163     {
2164         Status = I_RpcMapWin32Status(RpcExceptionCode());
2165     }
2166     RpcEndExcept;
2167 
2168     return Status;
2169 }
2170 
2171 
2172 /*
2173  * @unimplemented
2174  */
2175 NTSTATUS
2176 WINAPI
2177 LsaSetTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle,
2178                               IN PLSA_UNICODE_STRING TrustedDomainName,
2179                               IN TRUSTED_INFORMATION_CLASS InformationClass,
2180                               IN PVOID Buffer)
2181 {
2182     FIXME("LsaSetTrustedDomainInfoByName(%p %p %d %p) stub\n",
2183           PolicyHandle, TrustedDomainName, InformationClass, Buffer);
2184     return STATUS_SUCCESS;
2185 }
2186 
2187 
2188 /*
2189  * @unimplemented
2190  */
2191 NTSTATUS
2192 WINAPI
2193 LsaSetTrustedDomainInformation(IN LSA_HANDLE PolicyHandle,
2194                                IN PSID TrustedDomainSid,
2195                                IN TRUSTED_INFORMATION_CLASS InformationClass,
2196                                IN PVOID Buffer)
2197 {
2198     FIXME("LsaSetTrustedDomainInformation(%p %p %d %p) stub\n",
2199           PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
2200     return STATUS_SUCCESS;
2201 }
2202 
2203 
2204 /*
2205  * @implemented
2206  */
2207 NTSTATUS
2208 WINAPI
2209 LsaStorePrivateData(IN LSA_HANDLE PolicyHandle,
2210                     IN PLSA_UNICODE_STRING KeyName,
2211                     IN PLSA_UNICODE_STRING PrivateData OPTIONAL)
2212 {
2213     PLSAPR_CR_CIPHER_VALUE EncryptedData = NULL;
2214     SIZE_T BufferSize;
2215     NTSTATUS Status;
2216 
2217     TRACE("LsaStorePrivateData(%p %p %p)\n",
2218           PolicyHandle, KeyName, PrivateData);
2219 
2220     if (PrivateData != NULL)
2221     {
2222         BufferSize = sizeof(LSAPR_CR_CIPHER_VALUE) + PrivateData->MaximumLength;
2223         EncryptedData = midl_user_allocate(BufferSize);
2224         if (EncryptedData == NULL)
2225         {
2226             Status = STATUS_INSUFFICIENT_RESOURCES;
2227             goto done;
2228         }
2229 
2230         EncryptedData->Length = PrivateData->Length;
2231         EncryptedData->MaximumLength = PrivateData->MaximumLength;
2232         EncryptedData->Buffer = (BYTE *)(EncryptedData + 1);
2233         if (EncryptedData->Buffer != NULL)
2234             RtlCopyMemory(EncryptedData->Buffer,
2235                           PrivateData->Buffer,
2236                           PrivateData->Length);
2237     }
2238 
2239     RpcTryExcept
2240     {
2241         Status = LsarStorePrivateData((LSAPR_HANDLE)PolicyHandle,
2242                                       (PRPC_UNICODE_STRING)KeyName,
2243                                       EncryptedData);
2244     }
2245     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
2246     {
2247         Status = I_RpcMapWin32Status(RpcExceptionCode());
2248     }
2249     RpcEndExcept;
2250 
2251 done:
2252     if (EncryptedData != NULL)
2253         midl_user_free(EncryptedData);
2254 
2255     return Status;
2256 }
2257 
2258 /* EOF */
2259