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