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