ReactOS 0.4.17-dev-1321-g5c122a9
samrpc.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: Security Account Manager (SAM) Server
4 * FILE: reactos/dll/win32/samsrv/samrpc.c
5 * PURPOSE: RPC interface functions
6 *
7 * PROGRAMMERS: Eric Kohl
8 */
9
10#include "samsrv.h"
11
12/* GLOBALS *******************************************************************/
13
14static SID_IDENTIFIER_AUTHORITY NtSidAuthority = {SECURITY_NT_AUTHORITY};
15
16static GENERIC_MAPPING ServerMapping =
17{
18 SAM_SERVER_READ,
19 SAM_SERVER_WRITE,
20 SAM_SERVER_EXECUTE,
21 SAM_SERVER_ALL_ACCESS
22};
23
24static GENERIC_MAPPING DomainMapping =
25{
26 DOMAIN_READ,
27 DOMAIN_WRITE,
28 DOMAIN_EXECUTE,
29 DOMAIN_ALL_ACCESS
30};
31
32static GENERIC_MAPPING AliasMapping =
33{
34 ALIAS_READ,
35 ALIAS_WRITE,
36 ALIAS_EXECUTE,
37 ALIAS_ALL_ACCESS
38};
39
40static GENERIC_MAPPING GroupMapping =
41{
42 GROUP_READ,
43 GROUP_WRITE,
44 GROUP_EXECUTE,
45 GROUP_ALL_ACCESS
46};
47
48static GENERIC_MAPPING UserMapping =
49{
50 USER_READ,
51 USER_WRITE,
52 USER_EXECUTE,
53 USER_ALL_ACCESS
54};
55
56PGENERIC_MAPPING pServerMapping = &ServerMapping;
57
58
59/* FUNCTIONS *****************************************************************/
60
61static
62LARGE_INTEGER
63SampAddRelativeTimeToTime(IN LARGE_INTEGER AbsoluteTime,
64 IN LARGE_INTEGER RelativeTime)
65{
66 LARGE_INTEGER NewTime;
67
68 NewTime.QuadPart = AbsoluteTime.QuadPart - RelativeTime.QuadPart;
69
70 if (NewTime.QuadPart < 0)
71 NewTime.QuadPart = 0;
72
73 return NewTime;
74}
75
76
77VOID
78SampStartRpcServer(VOID)
79{
80 RPC_STATUS Status;
81
82 TRACE("SampStartRpcServer() called\n");
83
84 Status = RpcServerUseProtseqEpW(L"ncacn_np",
85 RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
86 L"\\pipe\\samr",
87 NULL);
88 if (Status != RPC_S_OK)
89 {
90 WARN("RpcServerUseProtseqEpW() failed (Status %lx)\n", Status);
91 return;
92 }
93
94 Status = RpcServerRegisterIf(samr_v1_0_s_ifspec,
95 NULL,
96 NULL);
97 if (Status != RPC_S_OK)
98 {
99 WARN("RpcServerRegisterIf() failed (Status %lx)\n", Status);
100 return;
101 }
102
103 Status = RpcServerListen(1, 20, TRUE);
104 if (Status != RPC_S_OK)
105 {
106 WARN("RpcServerListen() failed (Status %lx)\n", Status);
107 return;
108 }
109
110 TRACE("SampStartRpcServer() done\n");
111}
112
113
114void __RPC_FAR * __RPC_USER midl_user_allocate(SIZE_T len)
115{
116 return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
117}
118
119
120void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
121{
122 HeapFree(GetProcessHeap(), 0, ptr);
123}
124
125
126void __RPC_USER SAMPR_HANDLE_rundown(SAMPR_HANDLE hHandle)
127{
128 FIXME("SAMPR_HANDLE_rundown(%p)\n", hHandle);
129}
130
131
132/* Function 0 */
133NTSTATUS
134NTAPI
135SamrConnect(IN PSAMPR_SERVER_NAME ServerName,
136 OUT SAMPR_HANDLE *ServerHandle,
137 IN ACCESS_MASK DesiredAccess)
138{
139 SAMPR_REVISION_INFO InRevisionInfo, OutRevisionInfo;
140 ULONG OutVersion;
141
142 TRACE("SamrConnect(%p %p %lx)\n",
143 ServerName, ServerHandle, DesiredAccess);
144
145 InRevisionInfo.V1.Revision = 0;
146 InRevisionInfo.V1.SupportedFeatures = 0;
147
148 return SamrConnect5(ServerName,
149 DesiredAccess,
150 1,
151 &InRevisionInfo,
152 &OutVersion,
153 &OutRevisionInfo,
154 ServerHandle);
155}
156
157
158/* Function 1 */
159NTSTATUS
160NTAPI
161SamrCloseHandle(IN OUT SAMPR_HANDLE *SamHandle)
162{
163 PSAM_DB_OBJECT DbObject;
164 NTSTATUS Status = STATUS_SUCCESS;
165
166 TRACE("SamrCloseHandle(%p)\n", SamHandle);
167
168 RtlAcquireResourceShared(&SampResource,
169 TRUE);
170
171 Status = SampValidateDbObject(*SamHandle,
172 SamDbIgnoreObject,
173 0,
174 &DbObject);
175 if (Status == STATUS_SUCCESS)
176 {
177 Status = SampCloseDbObject(DbObject);
178 *SamHandle = NULL;
179 }
180
181 RtlReleaseResource(&SampResource);
182
183 TRACE("SamrCloseHandle done (Status 0x%08lx)\n", Status);
184
185 return Status;
186}
187
188
189/* Function 2 */
190NTSTATUS
191NTAPI
192SamrSetSecurityObject(IN SAMPR_HANDLE ObjectHandle,
193 IN SECURITY_INFORMATION SecurityInformation,
194 IN PSAMPR_SR_SECURITY_DESCRIPTOR SecurityDescriptor)
195{
196 PSAM_DB_OBJECT DbObject = NULL;
197 ACCESS_MASK DesiredAccess = 0;
198 PSECURITY_DESCRIPTOR RelativeSd = NULL;
199 ULONG RelativeSdSize = 0;
200 HANDLE TokenHandle = NULL;
201 PGENERIC_MAPPING Mapping;
202 NTSTATUS Status;
203
204 TRACE("SamrSetSecurityObject(%p %lx %p)\n",
205 ObjectHandle, SecurityInformation, SecurityDescriptor);
206
207 if ((SecurityDescriptor == NULL) ||
208 (SecurityDescriptor->SecurityDescriptor == NULL) ||
209 !RtlValidSecurityDescriptor((PSECURITY_DESCRIPTOR)SecurityDescriptor->SecurityDescriptor))
210 return ERROR_INVALID_PARAMETER;
211
212 if (SecurityInformation == 0 ||
213 SecurityInformation & ~(OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION
214 | DACL_SECURITY_INFORMATION | SACL_SECURITY_INFORMATION))
215 return ERROR_INVALID_PARAMETER;
216
217 if (SecurityInformation & SACL_SECURITY_INFORMATION)
218 DesiredAccess |= ACCESS_SYSTEM_SECURITY;
219
220 if (SecurityInformation & DACL_SECURITY_INFORMATION)
221 DesiredAccess |= WRITE_DAC;
222
223 if (SecurityInformation & (OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION))
224 DesiredAccess |= WRITE_OWNER;
225
226 if ((SecurityInformation & OWNER_SECURITY_INFORMATION) &&
227 (((PISECURITY_DESCRIPTOR)SecurityDescriptor)->Owner == NULL))
228 return ERROR_INVALID_PARAMETER;
229
230 if ((SecurityInformation & GROUP_SECURITY_INFORMATION) &&
231 (((PISECURITY_DESCRIPTOR)SecurityDescriptor)->Group == NULL))
232 return ERROR_INVALID_PARAMETER;
233
234 /* Validate the server handle */
235 Status = SampValidateDbObject(ObjectHandle,
236 SamDbIgnoreObject,
237 DesiredAccess,
238 &DbObject);
239 if (!NT_SUCCESS(Status))
240 goto done;
241
242 /* Get the mapping for the object type */
243 switch (DbObject->ObjectType)
244 {
245 case SamDbServerObject:
246 Mapping = &ServerMapping;
247 break;
248
249 case SamDbDomainObject:
250 Mapping = &DomainMapping;
251 break;
252
253 case SamDbAliasObject:
254 Mapping = &AliasMapping;
255 break;
256
257 case SamDbGroupObject:
258 Mapping = &GroupMapping;
259 break;
260
261 case SamDbUserObject:
262 Mapping = &UserMapping;
263 break;
264
265 default:
266 return STATUS_INVALID_HANDLE;
267 }
268
269 /* Get the size of the SD */
270 Status = SampGetObjectAttribute(DbObject,
271 L"SecDesc",
272 NULL,
273 NULL,
274 &RelativeSdSize);
275 if (!NT_SUCCESS(Status))
276 return Status;
277
278 /* Allocate a buffer for the SD */
279 RelativeSd = RtlAllocateHeap(RtlGetProcessHeap(), 0, RelativeSdSize);
280 if (RelativeSd == NULL)
281 return STATUS_INSUFFICIENT_RESOURCES;
282
283 /* Get the SD */
284 Status = SampGetObjectAttribute(DbObject,
285 L"SecDesc",
286 NULL,
287 RelativeSd,
288 &RelativeSdSize);
289 if (!NT_SUCCESS(Status))
290 goto done;
291
292 /* Build the new security descriptor */
293 Status = RtlSetSecurityObject(SecurityInformation,
294 (PSECURITY_DESCRIPTOR)SecurityDescriptor->SecurityDescriptor,
295 &RelativeSd,
296 Mapping,
297 TokenHandle);
298 if (!NT_SUCCESS(Status))
299 {
300 ERR("RtlSetSecurityObject failed (Status 0x%08lx)\n", Status);
301 goto done;
302 }
303
304 /* Set the modified SD */
305 Status = SampSetObjectAttribute(DbObject,
306 L"SecDesc",
307 REG_BINARY,
308 RelativeSd,
309 RtlLengthSecurityDescriptor(RelativeSd));
310 if (!NT_SUCCESS(Status))
311 {
312 ERR("SampSetObjectAttribute failed (Status 0x%08lx)\n", Status);
313 }
314
315done:
316 if (TokenHandle != NULL)
317 NtClose(TokenHandle);
318
319 if (RelativeSd != NULL)
320 RtlFreeHeap(RtlGetProcessHeap(), 0, RelativeSd);
321
322 return Status;
323}
324
325
326/* Function 3 */
327NTSTATUS
328NTAPI
329SamrQuerySecurityObject(IN SAMPR_HANDLE ObjectHandle,
330 IN SECURITY_INFORMATION SecurityInformation,
331 OUT PSAMPR_SR_SECURITY_DESCRIPTOR *SecurityDescriptor)
332{
333 PSAM_DB_OBJECT SamObject;
334 PSAMPR_SR_SECURITY_DESCRIPTOR SdData = NULL;
335 PISECURITY_DESCRIPTOR_RELATIVE RelativeSd = NULL;
336 PSECURITY_DESCRIPTOR ResultSd = NULL;
337 ACCESS_MASK DesiredAccess = 0;
338 ULONG RelativeSdSize = 0;
339 ULONG ResultSdSize = 0;
340 NTSTATUS Status;
341
342 TRACE("SamrQuerySecurityObject(%p %lx %p)\n",
343 ObjectHandle, SecurityInformation, SecurityDescriptor);
344
345 *SecurityDescriptor = NULL;
346
347 RtlAcquireResourceShared(&SampResource,
348 TRUE);
349
350 if (SecurityInformation & (DACL_SECURITY_INFORMATION |
351 OWNER_SECURITY_INFORMATION |
352 GROUP_SECURITY_INFORMATION))
353 DesiredAccess |= READ_CONTROL;
354
355 if (SecurityInformation & SACL_SECURITY_INFORMATION)
356 DesiredAccess |= ACCESS_SYSTEM_SECURITY;
357
358 /* Validate the server handle */
359 Status = SampValidateDbObject(ObjectHandle,
360 SamDbIgnoreObject,
361 DesiredAccess,
362 &SamObject);
363 if (!NT_SUCCESS(Status))
364 goto done;
365
366 /* Get the size of the SD */
367 Status = SampGetObjectAttribute(SamObject,
368 L"SecDesc",
369 NULL,
370 NULL,
371 &RelativeSdSize);
372 if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW)
373 {
374 TRACE("Status 0x%08lx\n", Status);
375 goto done;
376 }
377
378 /* Allocate a buffer for the SD */
379 RelativeSd = midl_user_allocate(RelativeSdSize);
380 if (RelativeSd == NULL)
381 {
382 Status = STATUS_INSUFFICIENT_RESOURCES;
383 goto done;
384 }
385
386 /* Get the SD */
387 Status = SampGetObjectAttribute(SamObject,
388 L"SecDesc",
389 NULL,
390 RelativeSd,
391 &RelativeSdSize);
392 if (!NT_SUCCESS(Status))
393 {
394 TRACE("Status 0x%08lx\n", Status);
395 goto done;
396 }
397
398 /* Invalidate the SD information that was not requested */
399 if (!(SecurityInformation & OWNER_SECURITY_INFORMATION))
400 RelativeSd->Owner = 0;
401
402 if (!(SecurityInformation & GROUP_SECURITY_INFORMATION))
403 RelativeSd->Group = 0;
404
405 if (!(SecurityInformation & DACL_SECURITY_INFORMATION))
406 RelativeSd->Control &= ~SE_DACL_PRESENT;
407
408 if (!(SecurityInformation & SACL_SECURITY_INFORMATION))
409 RelativeSd->Control &= ~SE_SACL_PRESENT;
410
411 /* Calculate the required SD size */
412 Status = RtlMakeSelfRelativeSD(RelativeSd,
413 NULL,
414 &ResultSdSize);
415 if (Status != STATUS_BUFFER_TOO_SMALL)
416 goto done;
417
418 /* Allocate a buffer for the new SD */
419 ResultSd = MIDL_user_allocate(ResultSdSize);
420 if (ResultSd == NULL)
421 {
422 Status = STATUS_INSUFFICIENT_RESOURCES;
423 goto done;
424 }
425
426 /* Build the new SD */
427 Status = RtlMakeSelfRelativeSD(RelativeSd,
428 ResultSd,
429 &ResultSdSize);
430 if (!NT_SUCCESS(Status))
431 goto done;
432
433 /* Allocate the SD data buffer */
434 SdData = midl_user_allocate(sizeof(SAMPR_SR_SECURITY_DESCRIPTOR));
435 if (SdData == NULL)
436 {
437 Status = STATUS_INSUFFICIENT_RESOURCES;
438 goto done;
439 }
440
441 /* Fill the SD data buffer and return it to the caller */
442 SdData->Length = ResultSdSize;
443 SdData->SecurityDescriptor = (PBYTE)ResultSd;
444
445 *SecurityDescriptor = SdData;
446
447done:
448 RtlReleaseResource(&SampResource);
449
450 if (!NT_SUCCESS(Status))
451 {
452 if (ResultSd != NULL)
453 MIDL_user_free(ResultSd);
454 }
455
456 if (RelativeSd != NULL)
457 MIDL_user_free(RelativeSd);
458
459 return Status;
460}
461
462
463/* Function 4 */
464NTSTATUS
465NTAPI
466SamrShutdownSamServer(IN SAMPR_HANDLE ServerHandle)
467{
468 PSAM_DB_OBJECT ServerObject;
469 NTSTATUS Status;
470
471 TRACE("SamrShutdownSamServer(%p)\n",
472 ServerHandle);
473
474 RtlAcquireResourceShared(&SampResource,
475 TRUE);
476
477 /* Validate the server handle */
478 Status = SampValidateDbObject(ServerHandle,
479 SamDbServerObject,
480 SAM_SERVER_SHUTDOWN,
481 &ServerObject);
482
483 RtlReleaseResource(&SampResource);
484
485 if (!NT_SUCCESS(Status))
486 return Status;
487
488 /* Shut the server down */
489 RpcMgmtStopServerListening(0);
490
491 Status = SampShutdownDisplayCache();
492 if (!NT_SUCCESS(Status))
493 {
494 ERR("SampShutdownDisplayCache() failed (Status 0x%08lx)\n", Status);
495 }
496
497 return STATUS_SUCCESS;
498}
499
500
501/* Function 5 */
502NTSTATUS
503NTAPI
504SamrLookupDomainInSamServer(IN SAMPR_HANDLE ServerHandle,
505 IN PRPC_UNICODE_STRING Name,
506 OUT PRPC_SID *DomainId)
507{
508 PSAM_DB_OBJECT ServerObject;
509 HANDLE DomainsKeyHandle = NULL;
510 HANDLE DomainKeyHandle = NULL;
511 WCHAR DomainKeyName[64];
512 ULONG Index;
513 WCHAR DomainNameString[MAX_COMPUTERNAME_LENGTH + 1];
514 UNICODE_STRING DomainName;
515 ULONG Length;
516 BOOL Found = FALSE;
517 NTSTATUS Status;
518
519 TRACE("SamrLookupDomainInSamServer(%p %p %p)\n",
520 ServerHandle, Name, DomainId);
521
522 RtlAcquireResourceShared(&SampResource,
523 TRUE);
524
525 /* Validate the server handle */
526 Status = SampValidateDbObject(ServerHandle,
527 SamDbServerObject,
528 SAM_SERVER_LOOKUP_DOMAIN,
529 &ServerObject);
530 if (!NT_SUCCESS(Status))
531 goto done;
532
533 *DomainId = NULL;
534
535 Status = SampRegOpenKey(ServerObject->KeyHandle,
536 L"Domains",
537 KEY_READ,
538 &DomainsKeyHandle);
539 if (!NT_SUCCESS(Status))
540 goto done;
541
542 Index = 0;
543 while (Found == FALSE)
544 {
545 Status = SampRegEnumerateSubKey(DomainsKeyHandle,
546 Index,
547 64,
548 DomainKeyName);
549 if (!NT_SUCCESS(Status))
550 {
551 if (Status == STATUS_NO_MORE_ENTRIES)
552 Status = STATUS_NO_SUCH_DOMAIN;
553 break;
554 }
555
556 TRACE("Domain key name: %S\n", DomainKeyName);
557
558 Status = SampRegOpenKey(DomainsKeyHandle,
559 DomainKeyName,
560 KEY_READ,
561 &DomainKeyHandle);
562 if (NT_SUCCESS(Status))
563 {
564 Length = (MAX_COMPUTERNAME_LENGTH + 1) * sizeof(WCHAR);
565 Status = SampRegQueryValue(DomainKeyHandle,
566 L"Name",
567 NULL,
568 (PVOID)&DomainNameString,
569 &Length);
570 if (NT_SUCCESS(Status))
571 {
572 TRACE("Domain name: %S\n", DomainNameString);
573
574 RtlInitUnicodeString(&DomainName,
575 DomainNameString);
576 if (RtlEqualUnicodeString(&DomainName, (PUNICODE_STRING)Name, TRUE))
577 {
578 TRACE("Found it!\n");
579 Found = TRUE;
580
581 Status = SampRegQueryValue(DomainKeyHandle,
582 L"SID",
583 NULL,
584 NULL,
585 &Length);
586 if (NT_SUCCESS(Status))
587 {
588 *DomainId = midl_user_allocate(Length);
589
590 SampRegQueryValue(DomainKeyHandle,
591 L"SID",
592 NULL,
593 (PVOID)*DomainId,
594 &Length);
595
596 Status = STATUS_SUCCESS;
597 break;
598 }
599 }
600 }
601
602 SampRegCloseKey(&DomainKeyHandle);
603 }
604
605 Index++;
606 }
607
608done:
609 SampRegCloseKey(&DomainKeyHandle);
610 SampRegCloseKey(&DomainsKeyHandle);
611
612 RtlReleaseResource(&SampResource);
613
614 return Status;
615}
616
617
618/* Function 6 */
619NTSTATUS
620NTAPI
621SamrEnumerateDomainsInSamServer(IN SAMPR_HANDLE ServerHandle,
622 IN OUT unsigned long *EnumerationContext,
623 OUT PSAMPR_ENUMERATION_BUFFER *Buffer,
624 IN ULONG PreferedMaximumLength,
625 OUT PULONG CountReturned)
626{
627 PSAM_DB_OBJECT ServerObject;
628 WCHAR DomainKeyName[64];
629 HANDLE DomainsKeyHandle = NULL;
630 HANDLE DomainKeyHandle = NULL;
631 ULONG EnumIndex;
632 ULONG EnumCount;
633 ULONG RequiredLength;
634 ULONG DataLength;
635 ULONG i;
636 PSAMPR_ENUMERATION_BUFFER EnumBuffer = NULL;
637 NTSTATUS Status;
638
639 TRACE("SamrEnumerateDomainsInSamServer(%p %p %p %lu %p)\n",
640 ServerHandle, EnumerationContext, Buffer, PreferedMaximumLength,
641 CountReturned);
642
643 RtlAcquireResourceShared(&SampResource,
644 TRUE);
645
646 /* Validate the server handle */
647 Status = SampValidateDbObject(ServerHandle,
648 SamDbServerObject,
649 SAM_SERVER_ENUMERATE_DOMAINS,
650 &ServerObject);
651 if (!NT_SUCCESS(Status))
652 goto done;
653
654 Status = SampRegOpenKey(ServerObject->KeyHandle,
655 L"Domains",
656 KEY_READ,
657 &DomainsKeyHandle);
658 if (!NT_SUCCESS(Status))
659 goto done;
660
661 EnumIndex = *EnumerationContext;
662 EnumCount = 0;
663 RequiredLength = 0;
664
665 while (TRUE)
666 {
667 Status = SampRegEnumerateSubKey(DomainsKeyHandle,
668 EnumIndex,
669 64 * sizeof(WCHAR),
670 DomainKeyName);
671 if (!NT_SUCCESS(Status))
672 break;
673
674 TRACE("EnumIndex: %lu\n", EnumIndex);
675 TRACE("Domain key name: %S\n", DomainKeyName);
676
677 Status = SampRegOpenKey(DomainsKeyHandle,
678 DomainKeyName,
679 KEY_READ,
680 &DomainKeyHandle);
681 TRACE("SampRegOpenKey returned %08lX\n", Status);
682 if (NT_SUCCESS(Status))
683 {
684 DataLength = 0;
685 Status = SampRegQueryValue(DomainKeyHandle,
686 L"Name",
687 NULL,
688 NULL,
689 &DataLength);
690 TRACE("SampRegQueryValue returned %08lX\n", Status);
691 if (NT_SUCCESS(Status))
692 {
693 TRACE("Data length: %lu\n", DataLength);
694
695 if ((RequiredLength + DataLength + sizeof(UNICODE_STRING)) > PreferedMaximumLength)
696 break;
697
698 RequiredLength += (DataLength + sizeof(UNICODE_STRING));
699 EnumCount++;
700 }
701
702 SampRegCloseKey(&DomainKeyHandle);
703 }
704
705 EnumIndex++;
706 }
707
708 TRACE("EnumCount: %lu\n", EnumCount);
709 TRACE("RequiredLength: %lu\n", RequiredLength);
710
711 EnumBuffer = midl_user_allocate(sizeof(SAMPR_ENUMERATION_BUFFER));
712 if (EnumBuffer == NULL)
713 {
714 Status = STATUS_INSUFFICIENT_RESOURCES;
715 goto done;
716 }
717
718 EnumBuffer->EntriesRead = EnumCount;
719 EnumBuffer->Buffer = midl_user_allocate(EnumCount * sizeof(SAMPR_RID_ENUMERATION));
720 if (EnumBuffer->Buffer == NULL)
721 {
722 Status = STATUS_INSUFFICIENT_RESOURCES;
723 goto done;
724 }
725
726 EnumIndex = *EnumerationContext;
727 for (i = 0; i < EnumCount; i++, EnumIndex++)
728 {
729 Status = SampRegEnumerateSubKey(DomainsKeyHandle,
730 EnumIndex,
731 64 * sizeof(WCHAR),
732 DomainKeyName);
733 if (!NT_SUCCESS(Status))
734 break;
735
736 TRACE("EnumIndex: %lu\n", EnumIndex);
737 TRACE("Domain key name: %S\n", DomainKeyName);
738
739 Status = SampRegOpenKey(DomainsKeyHandle,
740 DomainKeyName,
741 KEY_READ,
742 &DomainKeyHandle);
743 TRACE("SampRegOpenKey returned %08lX\n", Status);
744 if (NT_SUCCESS(Status))
745 {
746 DataLength = 0;
747 Status = SampRegQueryValue(DomainKeyHandle,
748 L"Name",
749 NULL,
750 NULL,
751 &DataLength);
752 TRACE("SampRegQueryValue returned %08lX\n", Status);
753 if (NT_SUCCESS(Status))
754 {
755 EnumBuffer->Buffer[i].RelativeId = 0;
756 EnumBuffer->Buffer[i].Name.Length = (USHORT)DataLength - sizeof(WCHAR);
757 EnumBuffer->Buffer[i].Name.MaximumLength = (USHORT)DataLength;
758 EnumBuffer->Buffer[i].Name.Buffer = midl_user_allocate(DataLength);
759 if (EnumBuffer->Buffer[i].Name.Buffer == NULL)
760 {
761 SampRegCloseKey(&DomainKeyHandle);
762 Status = STATUS_INSUFFICIENT_RESOURCES;
763 goto done;
764 }
765
766 Status = SampRegQueryValue(DomainKeyHandle,
767 L"Name",
768 NULL,
769 EnumBuffer->Buffer[i].Name.Buffer,
770 &DataLength);
771 TRACE("SampRegQueryValue returned %08lX\n", Status);
772 if (NT_SUCCESS(Status))
773 {
774 TRACE("Domain name: %S\n", EnumBuffer->Buffer[i].Name.Buffer);
775 }
776 }
777
778 SampRegCloseKey(&DomainKeyHandle);
779
780 if (!NT_SUCCESS(Status))
781 goto done;
782 }
783 }
784
785 if (NT_SUCCESS(Status))
786 {
787 *EnumerationContext += EnumCount;
788 *Buffer = EnumBuffer;
789 *CountReturned = EnumCount;
790 }
791
792done:
793 SampRegCloseKey(&DomainKeyHandle);
794 SampRegCloseKey(&DomainsKeyHandle);
795
796 if (!NT_SUCCESS(Status))
797 {
798 *EnumerationContext = 0;
799 *Buffer = NULL;
800 *CountReturned = 0;
801
802 if (EnumBuffer != NULL)
803 {
804 if (EnumBuffer->Buffer != NULL)
805 {
806 if (EnumBuffer->EntriesRead != 0)
807 {
808 for (i = 0; i < EnumBuffer->EntriesRead; i++)
809 {
810 if (EnumBuffer->Buffer[i].Name.Buffer != NULL)
811 midl_user_free(EnumBuffer->Buffer[i].Name.Buffer);
812 }
813 }
814
815 midl_user_free(EnumBuffer->Buffer);
816 }
817
818 midl_user_free(EnumBuffer);
819 }
820 }
821
822 RtlReleaseResource(&SampResource);
823
824 return Status;
825}
826
827
828/* Function 7 */
829NTSTATUS
830NTAPI
831SamrOpenDomain(IN SAMPR_HANDLE ServerHandle,
832 IN ACCESS_MASK DesiredAccess,
833 IN PRPC_SID DomainId,
834 OUT SAMPR_HANDLE *DomainHandle)
835{
836 PSAM_DB_OBJECT ServerObject;
837 PSAM_DB_OBJECT DomainObject;
838 NTSTATUS Status;
839
840 TRACE("SamrOpenDomain(%p %lx %p %p)\n",
841 ServerHandle, DesiredAccess, DomainId, DomainHandle);
842
843 /* Map generic access rights */
844 RtlMapGenericMask(&DesiredAccess,
845 &DomainMapping);
846
847 RtlAcquireResourceShared(&SampResource,
848 TRUE);
849
850 /* Validate the server handle */
851 Status = SampValidateDbObject(ServerHandle,
852 SamDbServerObject,
853 SAM_SERVER_LOOKUP_DOMAIN,
854 &ServerObject);
855 if (!NT_SUCCESS(Status))
856 goto done;
857
858 /* Validate the Domain SID */
859 if ((DomainId->Revision != SID_REVISION) ||
860 (DomainId->SubAuthorityCount > SID_MAX_SUB_AUTHORITIES) ||
861 (memcmp(&DomainId->IdentifierAuthority, &NtSidAuthority, sizeof(SID_IDENTIFIER_AUTHORITY)) != 0))
862 {
863 Status = STATUS_INVALID_PARAMETER;
864 goto done;
865 }
866
867 /* Open the domain object */
868 if ((DomainId->SubAuthorityCount == 1) &&
869 (DomainId->SubAuthority[0] == SECURITY_BUILTIN_DOMAIN_RID))
870 {
871 /* Builtin domain object */
872 TRACE("Opening the builtin domain object.\n");
873
874 Status = SampOpenDbObject(ServerObject,
875 L"Domains",
876 L"Builtin",
877 0,
878 SamDbDomainObject,
879 DesiredAccess,
880 &DomainObject);
881 }
882 else if ((DomainId->SubAuthorityCount == 4) &&
883 (DomainId->SubAuthority[0] == SECURITY_NT_NON_UNIQUE))
884 {
885 /* Account domain object */
886 TRACE("Opening the account domain object.\n");
887
888 /* FIXME: Check the account domain sub authorities!!! */
889
890 Status = SampOpenDbObject(ServerObject,
891 L"Domains",
892 L"Account",
893 0,
894 SamDbDomainObject,
895 DesiredAccess,
896 &DomainObject);
897 }
898 else
899 {
900 /* No valid domain SID */
901 Status = STATUS_INVALID_PARAMETER;
902 }
903
904 if (NT_SUCCESS(Status))
905 *DomainHandle = (SAMPR_HANDLE)DomainObject;
906
907done:
908 RtlReleaseResource(&SampResource);
909
910 TRACE("SamrOpenDomain done (Status 0x%08lx)\n", Status);
911
912 return Status;
913}
914
915
916static NTSTATUS
917SampQueryDomainPassword(PSAM_DB_OBJECT DomainObject,
918 PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
919{
920 PSAMPR_DOMAIN_INFO_BUFFER InfoBuffer = NULL;
921 SAM_DOMAIN_FIXED_DATA FixedData;
922 ULONG Length = 0;
923 NTSTATUS Status;
924
925 *Buffer = NULL;
926
927 InfoBuffer = midl_user_allocate(sizeof(SAMPR_DOMAIN_INFO_BUFFER));
928 if (InfoBuffer == NULL)
929 return STATUS_INSUFFICIENT_RESOURCES;
930
931 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
932 Status = SampGetObjectAttribute(DomainObject,
933 L"F",
934 NULL,
935 (PVOID)&FixedData,
936 &Length);
937 if (!NT_SUCCESS(Status))
938 goto done;
939
940 InfoBuffer->Password.MinPasswordLength = FixedData.MinPasswordLength;
941 InfoBuffer->Password.PasswordHistoryLength = FixedData.PasswordHistoryLength;
942 InfoBuffer->Password.PasswordProperties = FixedData.PasswordProperties;
943 InfoBuffer->Password.MaxPasswordAge.LowPart = FixedData.MaxPasswordAge.LowPart;
944 InfoBuffer->Password.MaxPasswordAge.HighPart = FixedData.MaxPasswordAge.HighPart;
945 InfoBuffer->Password.MinPasswordAge.LowPart = FixedData.MinPasswordAge.LowPart;
946 InfoBuffer->Password.MinPasswordAge.HighPart = FixedData.MinPasswordAge.HighPart;
947
948 *Buffer = InfoBuffer;
949
950done:
951 if (!NT_SUCCESS(Status))
952 {
953 if (InfoBuffer != NULL)
954 {
955 midl_user_free(InfoBuffer);
956 }
957 }
958
959 return Status;
960}
961
962
963static NTSTATUS
964SampGetNumberOfAccounts(PSAM_DB_OBJECT DomainObject,
965 LPCWSTR AccountType,
966 PULONG Count)
967{
968 HANDLE AccountKeyHandle = NULL;
969 HANDLE NamesKeyHandle = NULL;
970 NTSTATUS Status;
971
972 *Count = 0;
973
974 Status = SampRegOpenKey(DomainObject->KeyHandle,
975 AccountType,
976 KEY_READ,
977 &AccountKeyHandle);
978 if (!NT_SUCCESS(Status))
979 return Status;
980
981 Status = SampRegOpenKey(AccountKeyHandle,
982 L"Names",
983 KEY_READ,
984 &NamesKeyHandle);
985 if (!NT_SUCCESS(Status))
986 goto done;
987
988 Status = SampRegQueryKeyInfo(NamesKeyHandle,
989 NULL,
990 Count);
991
992done:
993 SampRegCloseKey(&NamesKeyHandle);
994 SampRegCloseKey(&AccountKeyHandle);
995
996 return Status;
997}
998
999
1000static NTSTATUS
1001SampQueryDomainGeneral(PSAM_DB_OBJECT DomainObject,
1002 PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
1003{
1004 PSAMPR_DOMAIN_INFO_BUFFER InfoBuffer = NULL;
1005 SAM_DOMAIN_FIXED_DATA FixedData;
1006 ULONG Length = 0;
1007 NTSTATUS Status;
1008
1009 *Buffer = NULL;
1010
1011 InfoBuffer = midl_user_allocate(sizeof(SAMPR_DOMAIN_INFO_BUFFER));
1012 if (InfoBuffer == NULL)
1013 return STATUS_INSUFFICIENT_RESOURCES;
1014
1015 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1016 Status = SampGetObjectAttribute(DomainObject,
1017 L"F",
1018 NULL,
1019 (PVOID)&FixedData,
1020 &Length);
1021 if (!NT_SUCCESS(Status))
1022 goto done;
1023
1024 InfoBuffer->General.ForceLogoff.LowPart = FixedData.ForceLogoff.LowPart;
1025 InfoBuffer->General.ForceLogoff.HighPart = FixedData.ForceLogoff.HighPart;
1026 InfoBuffer->General.DomainModifiedCount.LowPart = FixedData.DomainModifiedCount.LowPart;
1027 InfoBuffer->General.DomainModifiedCount.HighPart = FixedData.DomainModifiedCount.HighPart;
1028 InfoBuffer->General.DomainServerState = FixedData.DomainServerState;
1029 InfoBuffer->General.DomainServerRole = FixedData.DomainServerRole;
1030 InfoBuffer->General.UasCompatibilityRequired = FixedData.UasCompatibilityRequired;
1031
1032 /* Get the OemInformation string */
1033 Status = SampGetObjectAttributeString(DomainObject,
1034 L"OemInformation",
1035 &InfoBuffer->General.OemInformation);
1036 if (!NT_SUCCESS(Status))
1037 {
1038 TRACE("Status 0x%08lx\n", Status);
1039 goto done;
1040 }
1041
1042 /* Get the Name string */
1043 Status = SampGetObjectAttributeString(DomainObject,
1044 L"Name",
1045 &InfoBuffer->General.DomainName);
1046 if (!NT_SUCCESS(Status))
1047 {
1048 TRACE("Status 0x%08lx\n", Status);
1049 goto done;
1050 }
1051
1052 /* Get the ReplicaSourceNodeName string */
1053 Status = SampGetObjectAttributeString(DomainObject,
1054 L"ReplicaSourceNodeName",
1055 &InfoBuffer->General.ReplicaSourceNodeName);
1056 if (!NT_SUCCESS(Status))
1057 {
1058 TRACE("Status 0x%08lx\n", Status);
1059 goto done;
1060 }
1061
1062 /* Get the number of Users in the Domain */
1063 Status = SampGetNumberOfAccounts(DomainObject,
1064 L"Users",
1065 &InfoBuffer->General.UserCount);
1066 if (!NT_SUCCESS(Status))
1067 {
1068 TRACE("Status 0x%08lx\n", Status);
1069 goto done;
1070 }
1071
1072 /* Get the number of Groups in the Domain */
1073 Status = SampGetNumberOfAccounts(DomainObject,
1074 L"Groups",
1075 &InfoBuffer->General.GroupCount);
1076 if (!NT_SUCCESS(Status))
1077 {
1078 TRACE("Status 0x%08lx\n", Status);
1079 goto done;
1080 }
1081
1082 /* Get the number of Aliases in the Domain */
1083 Status = SampGetNumberOfAccounts(DomainObject,
1084 L"Aliases",
1085 &InfoBuffer->General.AliasCount);
1086 if (!NT_SUCCESS(Status))
1087 {
1088 TRACE("Status 0x%08lx\n", Status);
1089 goto done;
1090 }
1091
1092 *Buffer = InfoBuffer;
1093
1094done:
1095 if (!NT_SUCCESS(Status))
1096 {
1097 if (InfoBuffer != NULL)
1098 {
1099 if (InfoBuffer->General.OemInformation.Buffer != NULL)
1100 midl_user_free(InfoBuffer->General.OemInformation.Buffer);
1101
1102 if (InfoBuffer->General.DomainName.Buffer != NULL)
1103 midl_user_free(InfoBuffer->General.DomainName.Buffer);
1104
1105 if (InfoBuffer->General.ReplicaSourceNodeName.Buffer != NULL)
1106 midl_user_free(InfoBuffer->General.ReplicaSourceNodeName.Buffer);
1107
1108 midl_user_free(InfoBuffer);
1109 }
1110 }
1111
1112 return Status;
1113}
1114
1115
1116static NTSTATUS
1117SampQueryDomainLogoff(PSAM_DB_OBJECT DomainObject,
1118 PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
1119{
1120 PSAMPR_DOMAIN_INFO_BUFFER InfoBuffer = NULL;
1121 SAM_DOMAIN_FIXED_DATA FixedData;
1122 ULONG Length = 0;
1123 NTSTATUS Status;
1124
1125 *Buffer = NULL;
1126
1127 InfoBuffer = midl_user_allocate(sizeof(SAMPR_DOMAIN_INFO_BUFFER));
1128 if (InfoBuffer == NULL)
1129 return STATUS_INSUFFICIENT_RESOURCES;
1130
1131 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1132 Status = SampGetObjectAttribute(DomainObject,
1133 L"F",
1134 NULL,
1135 (PVOID)&FixedData,
1136 &Length);
1137 if (!NT_SUCCESS(Status))
1138 goto done;
1139
1140 InfoBuffer->Logoff.ForceLogoff.LowPart = FixedData.ForceLogoff.LowPart;
1141 InfoBuffer->Logoff.ForceLogoff.HighPart = FixedData.ForceLogoff.HighPart;
1142
1143 *Buffer = InfoBuffer;
1144
1145done:
1146 if (!NT_SUCCESS(Status))
1147 {
1148 if (InfoBuffer != NULL)
1149 {
1150 midl_user_free(InfoBuffer);
1151 }
1152 }
1153
1154 return Status;
1155}
1156
1157
1158static NTSTATUS
1159SampQueryDomainOem(PSAM_DB_OBJECT DomainObject,
1160 PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
1161{
1162 PSAMPR_DOMAIN_INFO_BUFFER InfoBuffer = NULL;
1163 NTSTATUS Status;
1164
1165 *Buffer = NULL;
1166
1167 InfoBuffer = midl_user_allocate(sizeof(SAMPR_DOMAIN_INFO_BUFFER));
1168 if (InfoBuffer == NULL)
1169 return STATUS_INSUFFICIENT_RESOURCES;
1170
1171 /* Get the OemInformation string */
1172 Status = SampGetObjectAttributeString(DomainObject,
1173 L"OemInformation",
1174 &InfoBuffer->Oem.OemInformation);
1175 if (!NT_SUCCESS(Status))
1176 {
1177 TRACE("Status 0x%08lx\n", Status);
1178 goto done;
1179 }
1180
1181 *Buffer = InfoBuffer;
1182
1183done:
1184 if (!NT_SUCCESS(Status))
1185 {
1186 if (InfoBuffer != NULL)
1187 {
1188 if (InfoBuffer->Oem.OemInformation.Buffer != NULL)
1189 midl_user_free(InfoBuffer->Oem.OemInformation.Buffer);
1190
1191 midl_user_free(InfoBuffer);
1192 }
1193 }
1194
1195 return Status;
1196}
1197
1198
1199static NTSTATUS
1200SampQueryDomainName(PSAM_DB_OBJECT DomainObject,
1201 PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
1202{
1203 PSAMPR_DOMAIN_INFO_BUFFER InfoBuffer = NULL;
1204 NTSTATUS Status;
1205
1206 *Buffer = NULL;
1207
1208 InfoBuffer = midl_user_allocate(sizeof(SAMPR_DOMAIN_INFO_BUFFER));
1209 if (InfoBuffer == NULL)
1210 return STATUS_INSUFFICIENT_RESOURCES;
1211
1212 /* Get the Name string */
1213 Status = SampGetObjectAttributeString(DomainObject,
1214 L"Name",
1215 &InfoBuffer->Name.DomainName);
1216 if (!NT_SUCCESS(Status))
1217 {
1218 TRACE("Status 0x%08lx\n", Status);
1219 goto done;
1220 }
1221
1222 *Buffer = InfoBuffer;
1223
1224done:
1225 if (!NT_SUCCESS(Status))
1226 {
1227 if (InfoBuffer != NULL)
1228 {
1229 if (InfoBuffer->Name.DomainName.Buffer != NULL)
1230 midl_user_free(InfoBuffer->Name.DomainName.Buffer);
1231
1232 midl_user_free(InfoBuffer);
1233 }
1234 }
1235
1236 return Status;
1237}
1238
1239
1240static NTSTATUS
1241SampQueryDomainReplication(PSAM_DB_OBJECT DomainObject,
1242 PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
1243{
1244 PSAMPR_DOMAIN_INFO_BUFFER InfoBuffer = NULL;
1245 NTSTATUS Status;
1246
1247 *Buffer = NULL;
1248
1249 InfoBuffer = midl_user_allocate(sizeof(SAMPR_DOMAIN_INFO_BUFFER));
1250 if (InfoBuffer == NULL)
1251 return STATUS_INSUFFICIENT_RESOURCES;
1252
1253 /* Get the ReplicaSourceNodeName string */
1254 Status = SampGetObjectAttributeString(DomainObject,
1255 L"ReplicaSourceNodeName",
1256 &InfoBuffer->Replication.ReplicaSourceNodeName);
1257 if (!NT_SUCCESS(Status))
1258 {
1259 TRACE("Status 0x%08lx\n", Status);
1260 goto done;
1261 }
1262
1263 *Buffer = InfoBuffer;
1264
1265done:
1266 if (!NT_SUCCESS(Status))
1267 {
1268 if (InfoBuffer != NULL)
1269 {
1270 if (InfoBuffer->Replication.ReplicaSourceNodeName.Buffer != NULL)
1271 midl_user_free(InfoBuffer->Replication.ReplicaSourceNodeName.Buffer);
1272
1273 midl_user_free(InfoBuffer);
1274 }
1275 }
1276
1277 return Status;
1278}
1279
1280
1281static NTSTATUS
1282SampQueryDomainServerRole(PSAM_DB_OBJECT DomainObject,
1283 PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
1284{
1285 PSAMPR_DOMAIN_INFO_BUFFER InfoBuffer = NULL;
1286 SAM_DOMAIN_FIXED_DATA FixedData;
1287 ULONG Length = 0;
1288 NTSTATUS Status;
1289
1290 *Buffer = NULL;
1291
1292 InfoBuffer = midl_user_allocate(sizeof(SAMPR_DOMAIN_INFO_BUFFER));
1293 if (InfoBuffer == NULL)
1294 return STATUS_INSUFFICIENT_RESOURCES;
1295
1296 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1297 Status = SampGetObjectAttribute(DomainObject,
1298 L"F",
1299 NULL,
1300 (PVOID)&FixedData,
1301 &Length);
1302 if (!NT_SUCCESS(Status))
1303 goto done;
1304
1305 InfoBuffer->Role.DomainServerRole = FixedData.DomainServerRole;
1306
1307 *Buffer = InfoBuffer;
1308
1309done:
1310 if (!NT_SUCCESS(Status))
1311 {
1312 if (InfoBuffer != NULL)
1313 {
1314 midl_user_free(InfoBuffer);
1315 }
1316 }
1317
1318 return Status;
1319}
1320
1321
1322static NTSTATUS
1323SampQueryDomainModified(PSAM_DB_OBJECT DomainObject,
1324 PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
1325{
1326 PSAMPR_DOMAIN_INFO_BUFFER InfoBuffer = NULL;
1327 SAM_DOMAIN_FIXED_DATA FixedData;
1328 ULONG Length = 0;
1329 NTSTATUS Status;
1330
1331 *Buffer = NULL;
1332
1333 InfoBuffer = midl_user_allocate(sizeof(SAMPR_DOMAIN_INFO_BUFFER));
1334 if (InfoBuffer == NULL)
1335 return STATUS_INSUFFICIENT_RESOURCES;
1336
1337 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1338 Status = SampGetObjectAttribute(DomainObject,
1339 L"F",
1340 NULL,
1341 (PVOID)&FixedData,
1342 &Length);
1343 if (!NT_SUCCESS(Status))
1344 goto done;
1345
1346 InfoBuffer->Modified.DomainModifiedCount.LowPart = FixedData.DomainModifiedCount.LowPart;
1347 InfoBuffer->Modified.DomainModifiedCount.HighPart = FixedData.DomainModifiedCount.HighPart;
1348 InfoBuffer->Modified.CreationTime.LowPart = FixedData.CreationTime.LowPart;
1349 InfoBuffer->Modified.CreationTime.HighPart = FixedData.CreationTime.HighPart;
1350
1351 *Buffer = InfoBuffer;
1352
1353done:
1354 if (!NT_SUCCESS(Status))
1355 {
1356 if (InfoBuffer != NULL)
1357 {
1358 midl_user_free(InfoBuffer);
1359 }
1360 }
1361
1362 return Status;
1363}
1364
1365
1366static NTSTATUS
1367SampQueryDomainState(PSAM_DB_OBJECT DomainObject,
1368 PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
1369{
1370 PSAMPR_DOMAIN_INFO_BUFFER InfoBuffer = NULL;
1371 SAM_DOMAIN_FIXED_DATA FixedData;
1372 ULONG Length = 0;
1373 NTSTATUS Status;
1374
1375 *Buffer = NULL;
1376
1377 InfoBuffer = midl_user_allocate(sizeof(SAMPR_DOMAIN_INFO_BUFFER));
1378 if (InfoBuffer == NULL)
1379 return STATUS_INSUFFICIENT_RESOURCES;
1380
1381 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1382 Status = SampGetObjectAttribute(DomainObject,
1383 L"F",
1384 NULL,
1385 (PVOID)&FixedData,
1386 &Length);
1387 if (!NT_SUCCESS(Status))
1388 goto done;
1389
1390 InfoBuffer->State.DomainServerState = FixedData.DomainServerState;
1391
1392 *Buffer = InfoBuffer;
1393
1394done:
1395 if (!NT_SUCCESS(Status))
1396 {
1397 if (InfoBuffer != NULL)
1398 {
1399 midl_user_free(InfoBuffer);
1400 }
1401 }
1402
1403 return Status;
1404}
1405
1406
1407static NTSTATUS
1408SampQueryDomainGeneral2(PSAM_DB_OBJECT DomainObject,
1409 PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
1410{
1411 PSAMPR_DOMAIN_INFO_BUFFER InfoBuffer = NULL;
1412 SAM_DOMAIN_FIXED_DATA FixedData;
1413 ULONG Length = 0;
1414 NTSTATUS Status;
1415
1416 *Buffer = NULL;
1417
1418 InfoBuffer = midl_user_allocate(sizeof(SAMPR_DOMAIN_INFO_BUFFER));
1419 if (InfoBuffer == NULL)
1420 return STATUS_INSUFFICIENT_RESOURCES;
1421
1422 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1423 Status = SampGetObjectAttribute(DomainObject,
1424 L"F",
1425 NULL,
1426 (PVOID)&FixedData,
1427 &Length);
1428 if (!NT_SUCCESS(Status))
1429 goto done;
1430
1431 InfoBuffer->General2.I1.ForceLogoff.LowPart = FixedData.ForceLogoff.LowPart;
1432 InfoBuffer->General2.I1.ForceLogoff.HighPart = FixedData.ForceLogoff.HighPart;
1433 InfoBuffer->General2.I1.DomainModifiedCount.LowPart = FixedData.DomainModifiedCount.LowPart;
1434 InfoBuffer->General2.I1.DomainModifiedCount.HighPart = FixedData.DomainModifiedCount.HighPart;
1435 InfoBuffer->General2.I1.DomainServerState = FixedData.DomainServerState;
1436 InfoBuffer->General2.I1.DomainServerRole = FixedData.DomainServerRole;
1437 InfoBuffer->General2.I1.UasCompatibilityRequired = FixedData.UasCompatibilityRequired;
1438
1439 InfoBuffer->General2.LockoutDuration = FixedData.LockoutDuration;
1440 InfoBuffer->General2.LockoutObservationWindow = FixedData.LockoutObservationWindow;
1441 InfoBuffer->General2.LockoutThreshold = FixedData.LockoutThreshold;
1442
1443 /* Get the OemInformation string */
1444 Status = SampGetObjectAttributeString(DomainObject,
1445 L"OemInformation",
1446 &InfoBuffer->General2.I1.OemInformation);
1447 if (!NT_SUCCESS(Status))
1448 {
1449 TRACE("Status 0x%08lx\n", Status);
1450 goto done;
1451 }
1452
1453 /* Get the Name string */
1454 Status = SampGetObjectAttributeString(DomainObject,
1455 L"Name",
1456 &InfoBuffer->General2.I1.DomainName);
1457 if (!NT_SUCCESS(Status))
1458 {
1459 TRACE("Status 0x%08lx\n", Status);
1460 goto done;
1461 }
1462
1463 /* Get the ReplicaSourceNodeName string */
1464 Status = SampGetObjectAttributeString(DomainObject,
1465 L"ReplicaSourceNodeName",
1466 &InfoBuffer->General2.I1.ReplicaSourceNodeName);
1467 if (!NT_SUCCESS(Status))
1468 {
1469 TRACE("Status 0x%08lx\n", Status);
1470 goto done;
1471 }
1472
1473 /* Get the number of Users in the Domain */
1474 Status = SampGetNumberOfAccounts(DomainObject,
1475 L"Users",
1476 &InfoBuffer->General2.I1.UserCount);
1477 if (!NT_SUCCESS(Status))
1478 {
1479 TRACE("Status 0x%08lx\n", Status);
1480 goto done;
1481 }
1482
1483 /* Get the number of Groups in the Domain */
1484 Status = SampGetNumberOfAccounts(DomainObject,
1485 L"Groups",
1486 &InfoBuffer->General2.I1.GroupCount);
1487 if (!NT_SUCCESS(Status))
1488 {
1489 TRACE("Status 0x%08lx\n", Status);
1490 goto done;
1491 }
1492
1493 /* Get the number of Aliases in the Domain */
1494 Status = SampGetNumberOfAccounts(DomainObject,
1495 L"Aliases",
1496 &InfoBuffer->General2.I1.AliasCount);
1497 if (!NT_SUCCESS(Status))
1498 {
1499 TRACE("Status 0x%08lx\n", Status);
1500 goto done;
1501 }
1502
1503 *Buffer = InfoBuffer;
1504
1505done:
1506 if (!NT_SUCCESS(Status))
1507 {
1508 if (InfoBuffer != NULL)
1509 {
1510 if (InfoBuffer->General2.I1.OemInformation.Buffer != NULL)
1511 midl_user_free(InfoBuffer->General2.I1.OemInformation.Buffer);
1512
1513 if (InfoBuffer->General2.I1.DomainName.Buffer != NULL)
1514 midl_user_free(InfoBuffer->General2.I1.DomainName.Buffer);
1515
1516 if (InfoBuffer->General2.I1.ReplicaSourceNodeName.Buffer != NULL)
1517 midl_user_free(InfoBuffer->General2.I1.ReplicaSourceNodeName.Buffer);
1518
1519 midl_user_free(InfoBuffer);
1520 }
1521 }
1522
1523 return Status;
1524}
1525
1526
1527static NTSTATUS
1528SampQueryDomainLockout(PSAM_DB_OBJECT DomainObject,
1529 PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
1530{
1531 PSAMPR_DOMAIN_INFO_BUFFER InfoBuffer = NULL;
1532 SAM_DOMAIN_FIXED_DATA FixedData;
1533 ULONG Length = 0;
1534 NTSTATUS Status;
1535
1536 *Buffer = NULL;
1537
1538 InfoBuffer = midl_user_allocate(sizeof(SAMPR_DOMAIN_INFO_BUFFER));
1539 if (InfoBuffer == NULL)
1540 return STATUS_INSUFFICIENT_RESOURCES;
1541
1542 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1543 Status = SampGetObjectAttribute(DomainObject,
1544 L"F",
1545 NULL,
1546 (PVOID)&FixedData,
1547 &Length);
1548 if (!NT_SUCCESS(Status))
1549 goto done;
1550
1551 InfoBuffer->Lockout.LockoutDuration = FixedData.LockoutDuration;
1552 InfoBuffer->Lockout.LockoutObservationWindow = FixedData.LockoutObservationWindow;
1553 InfoBuffer->Lockout.LockoutThreshold = FixedData.LockoutThreshold;
1554
1555 *Buffer = InfoBuffer;
1556
1557done:
1558 if (!NT_SUCCESS(Status))
1559 {
1560 if (InfoBuffer != NULL)
1561 {
1562 midl_user_free(InfoBuffer);
1563 }
1564 }
1565
1566 return Status;
1567}
1568
1569
1570static NTSTATUS
1571SampQueryDomainModified2(PSAM_DB_OBJECT DomainObject,
1572 PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
1573{
1574 PSAMPR_DOMAIN_INFO_BUFFER InfoBuffer = NULL;
1575 SAM_DOMAIN_FIXED_DATA FixedData;
1576 ULONG Length = 0;
1577 NTSTATUS Status;
1578
1579 *Buffer = NULL;
1580
1581 InfoBuffer = midl_user_allocate(sizeof(SAMPR_DOMAIN_INFO_BUFFER));
1582 if (InfoBuffer == NULL)
1583 return STATUS_INSUFFICIENT_RESOURCES;
1584
1585 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1586 Status = SampGetObjectAttribute(DomainObject,
1587 L"F",
1588 NULL,
1589 (PVOID)&FixedData,
1590 &Length);
1591 if (!NT_SUCCESS(Status))
1592 goto done;
1593
1594 InfoBuffer->Modified2.DomainModifiedCount.LowPart = FixedData.DomainModifiedCount.LowPart;
1595 InfoBuffer->Modified2.DomainModifiedCount.HighPart = FixedData.DomainModifiedCount.HighPart;
1596 InfoBuffer->Modified2.CreationTime.LowPart = FixedData.CreationTime.LowPart;
1597 InfoBuffer->Modified2.CreationTime.HighPart = FixedData.CreationTime.HighPart;
1598 InfoBuffer->Modified2.ModifiedCountAtLastPromotion.LowPart = FixedData.ModifiedCountAtLastPromotion.LowPart;
1599 InfoBuffer->Modified2.ModifiedCountAtLastPromotion.HighPart = FixedData.ModifiedCountAtLastPromotion.HighPart;
1600
1601 *Buffer = InfoBuffer;
1602
1603done:
1604 if (!NT_SUCCESS(Status))
1605 {
1606 if (InfoBuffer != NULL)
1607 {
1608 midl_user_free(InfoBuffer);
1609 }
1610 }
1611
1612 return Status;
1613}
1614
1615
1616/* Function 8 */
1617NTSTATUS
1618NTAPI
1619SamrQueryInformationDomain(IN SAMPR_HANDLE DomainHandle,
1620 IN DOMAIN_INFORMATION_CLASS DomainInformationClass,
1621 OUT PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
1622{
1623 TRACE("SamrQueryInformationDomain(%p %lu %p)\n",
1624 DomainHandle, DomainInformationClass, Buffer);
1625
1626 return SamrQueryInformationDomain2(DomainHandle,
1627 DomainInformationClass,
1628 Buffer);
1629}
1630
1631
1632static NTSTATUS
1633SampSetDomainPassword(PSAM_DB_OBJECT DomainObject,
1634 PSAMPR_DOMAIN_INFO_BUFFER Buffer)
1635{
1636 SAM_DOMAIN_FIXED_DATA FixedData;
1637 ULONG Length = 0;
1638 NTSTATUS Status;
1639
1640 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1641 Status = SampGetObjectAttribute(DomainObject,
1642 L"F",
1643 NULL,
1644 (PVOID)&FixedData,
1645 &Length);
1646 if (!NT_SUCCESS(Status))
1647 goto done;
1648
1649 FixedData.MinPasswordLength = Buffer->Password.MinPasswordLength;
1650 FixedData.PasswordHistoryLength = Buffer->Password.PasswordHistoryLength;
1651 FixedData.PasswordProperties = Buffer->Password.PasswordProperties;
1652 FixedData.MaxPasswordAge.LowPart = Buffer->Password.MaxPasswordAge.LowPart;
1653 FixedData.MaxPasswordAge.HighPart = Buffer->Password.MaxPasswordAge.HighPart;
1654 FixedData.MinPasswordAge.LowPart = Buffer->Password.MinPasswordAge.LowPart;
1655 FixedData.MinPasswordAge.HighPart = Buffer->Password.MinPasswordAge.HighPart;
1656
1657 Status = SampSetObjectAttribute(DomainObject,
1658 L"F",
1659 REG_BINARY,
1660 &FixedData,
1661 Length);
1662
1663done:
1664 return Status;
1665}
1666
1667
1668static NTSTATUS
1669SampSetDomainLogoff(PSAM_DB_OBJECT DomainObject,
1670 PSAMPR_DOMAIN_INFO_BUFFER Buffer)
1671{
1672 SAM_DOMAIN_FIXED_DATA FixedData;
1673 ULONG Length = 0;
1674 NTSTATUS Status;
1675
1676 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1677 Status = SampGetObjectAttribute(DomainObject,
1678 L"F",
1679 NULL,
1680 (PVOID)&FixedData,
1681 &Length);
1682 if (!NT_SUCCESS(Status))
1683 goto done;
1684
1685 FixedData.ForceLogoff.LowPart = Buffer->Logoff.ForceLogoff.LowPart;
1686 FixedData.ForceLogoff.HighPart = Buffer->Logoff.ForceLogoff.HighPart;
1687
1688 Status = SampSetObjectAttribute(DomainObject,
1689 L"F",
1690 REG_BINARY,
1691 &FixedData,
1692 Length);
1693
1694done:
1695 return Status;
1696}
1697
1698
1699static NTSTATUS
1700SampSetDomainServerRole(PSAM_DB_OBJECT DomainObject,
1701 PSAMPR_DOMAIN_INFO_BUFFER Buffer)
1702{
1703 SAM_DOMAIN_FIXED_DATA FixedData;
1704 ULONG Length = 0;
1705 NTSTATUS Status;
1706
1707 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1708 Status = SampGetObjectAttribute(DomainObject,
1709 L"F",
1710 NULL,
1711 (PVOID)&FixedData,
1712 &Length);
1713 if (!NT_SUCCESS(Status))
1714 goto done;
1715
1716 FixedData.DomainServerRole = Buffer->Role.DomainServerRole;
1717
1718 Status = SampSetObjectAttribute(DomainObject,
1719 L"F",
1720 REG_BINARY,
1721 &FixedData,
1722 Length);
1723
1724done:
1725 return Status;
1726}
1727
1728
1729static NTSTATUS
1730SampSetDomainState(PSAM_DB_OBJECT DomainObject,
1731 PSAMPR_DOMAIN_INFO_BUFFER Buffer)
1732{
1733 SAM_DOMAIN_FIXED_DATA FixedData;
1734 ULONG Length = 0;
1735 NTSTATUS Status;
1736
1737 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1738 Status = SampGetObjectAttribute(DomainObject,
1739 L"F",
1740 NULL,
1741 (PVOID)&FixedData,
1742 &Length);
1743 if (!NT_SUCCESS(Status))
1744 goto done;
1745
1746 FixedData.DomainServerState = Buffer->State.DomainServerState;
1747
1748 Status = SampSetObjectAttribute(DomainObject,
1749 L"F",
1750 REG_BINARY,
1751 &FixedData,
1752 Length);
1753
1754done:
1755 return Status;
1756}
1757
1758
1759static NTSTATUS
1760SampSetDomainLockout(PSAM_DB_OBJECT DomainObject,
1761 PSAMPR_DOMAIN_INFO_BUFFER Buffer)
1762{
1763 SAM_DOMAIN_FIXED_DATA FixedData;
1764 ULONG Length = 0;
1765 NTSTATUS Status;
1766
1767 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
1768 Status = SampGetObjectAttribute(DomainObject,
1769 L"F",
1770 NULL,
1771 (PVOID)&FixedData,
1772 &Length);
1773 if (!NT_SUCCESS(Status))
1774 goto done;
1775
1776 FixedData.LockoutDuration = Buffer->Lockout.LockoutDuration;
1777 FixedData.LockoutObservationWindow = Buffer->Lockout.LockoutObservationWindow;
1778 FixedData.LockoutThreshold = Buffer->Lockout.LockoutThreshold;
1779
1780 Status = SampSetObjectAttribute(DomainObject,
1781 L"F",
1782 REG_BINARY,
1783 &FixedData,
1784 Length);
1785
1786done:
1787 return Status;
1788}
1789
1790
1791/* Function 9 */
1792NTSTATUS
1793NTAPI
1794SamrSetInformationDomain(IN SAMPR_HANDLE DomainHandle,
1795 IN DOMAIN_INFORMATION_CLASS DomainInformationClass,
1796 IN PSAMPR_DOMAIN_INFO_BUFFER DomainInformation)
1797{
1798 PSAM_DB_OBJECT DomainObject;
1799 ACCESS_MASK DesiredAccess;
1800 NTSTATUS Status;
1801
1802 TRACE("SamrSetInformationDomain(%p %lu %p)\n",
1803 DomainHandle, DomainInformationClass, DomainInformation);
1804
1805 switch (DomainInformationClass)
1806 {
1807 case DomainPasswordInformation:
1808 case DomainLockoutInformation:
1809 DesiredAccess = DOMAIN_WRITE_PASSWORD_PARAMS;
1810 break;
1811
1812 case DomainLogoffInformation:
1813 case DomainOemInformation:
1814 case DomainNameInformation:
1815 DesiredAccess = DOMAIN_WRITE_OTHER_PARAMETERS;
1816 break;
1817
1818 case DomainReplicationInformation:
1819 case DomainServerRoleInformation:
1820 case DomainStateInformation:
1821 DesiredAccess = DOMAIN_ADMINISTER_SERVER;
1822 break;
1823
1824 default:
1825 return STATUS_INVALID_INFO_CLASS;
1826 }
1827
1828 RtlAcquireResourceExclusive(&SampResource,
1829 TRUE);
1830
1831 /* Validate the server handle */
1832 Status = SampValidateDbObject(DomainHandle,
1833 SamDbDomainObject,
1834 DesiredAccess,
1835 &DomainObject);
1836 if (!NT_SUCCESS(Status))
1837 goto done;
1838
1839 switch (DomainInformationClass)
1840 {
1841 case DomainPasswordInformation:
1842 Status = SampSetDomainPassword(DomainObject,
1843 DomainInformation);
1844 break;
1845
1846 case DomainLogoffInformation:
1847 Status = SampSetDomainLogoff(DomainObject,
1848 DomainInformation);
1849 break;
1850
1851 case DomainOemInformation:
1852 Status = SampSetObjectAttributeString(DomainObject,
1853 L"OemInformation",
1854 &DomainInformation->Oem.OemInformation);
1855 break;
1856
1857 case DomainNameInformation:
1858 Status = SampSetObjectAttributeString(DomainObject,
1859 L"Name",
1860 &DomainInformation->Name.DomainName);
1861 break;
1862
1863 case DomainReplicationInformation:
1864 Status = SampSetObjectAttributeString(DomainObject,
1865 L"ReplicaSourceNodeName",
1866 &DomainInformation->Replication.ReplicaSourceNodeName);
1867 break;
1868
1869 case DomainServerRoleInformation:
1870 Status = SampSetDomainServerRole(DomainObject,
1871 DomainInformation);
1872 break;
1873
1874 case DomainStateInformation:
1875 Status = SampSetDomainState(DomainObject,
1876 DomainInformation);
1877 break;
1878
1879 case DomainLockoutInformation:
1880 Status = SampSetDomainLockout(DomainObject,
1881 DomainInformation);
1882 break;
1883
1884 default:
1885 Status = STATUS_NOT_IMPLEMENTED;
1886 }
1887
1888done:
1889 RtlReleaseResource(&SampResource);
1890
1891 return Status;
1892}
1893
1894
1895/* Function 10 */
1896NTSTATUS
1897NTAPI
1898SamrCreateGroupInDomain(IN SAMPR_HANDLE DomainHandle,
1899 IN PRPC_UNICODE_STRING Name,
1900 IN ACCESS_MASK DesiredAccess,
1901 OUT SAMPR_HANDLE *GroupHandle,
1902 OUT unsigned long *RelativeId)
1903{
1904 SAM_DOMAIN_FIXED_DATA FixedDomainData;
1905 SAM_GROUP_FIXED_DATA FixedGroupData;
1906 PSAM_DB_OBJECT DomainObject;
1907 PSAM_DB_OBJECT GroupObject;
1908 PSECURITY_DESCRIPTOR Sd = NULL;
1909 ULONG SdSize = 0;
1910 ULONG ulSize;
1911 ULONG ulRid;
1912 WCHAR szRid[9];
1913 NTSTATUS Status;
1914
1915 TRACE("SamrCreateGroupInDomain(%p %p %lx %p %p)\n",
1916 DomainHandle, Name, DesiredAccess, GroupHandle, RelativeId);
1917
1918 /* Map generic access rights */
1919 RtlMapGenericMask(&DesiredAccess,
1920 &GroupMapping);
1921
1922 RtlAcquireResourceExclusive(&SampResource,
1923 TRUE);
1924
1925 /* Validate the domain handle */
1926 Status = SampValidateDbObject(DomainHandle,
1927 SamDbDomainObject,
1928 DOMAIN_CREATE_GROUP,
1929 &DomainObject);
1930 if (!NT_SUCCESS(Status))
1931 {
1932 TRACE("failed with status 0x%08lx\n", Status);
1933 goto done;
1934 }
1935
1936 /* Check the group account name */
1937 Status = SampCheckAccountName(Name, 256);
1938 if (!NT_SUCCESS(Status))
1939 {
1940 TRACE("SampCheckAccountName failed (Status 0x%08lx)\n", Status);
1941 goto done;
1942 }
1943
1944 /* Check if the group name already exists in the domain */
1945 Status = SampCheckAccountNameInDomain(DomainObject,
1946 Name->Buffer);
1947 if (!NT_SUCCESS(Status))
1948 {
1949 TRACE("Group name \'%S\' already exists in domain (Status 0x%08lx)\n",
1950 Name->Buffer, Status);
1951 goto done;
1952 }
1953
1954 /* Create the security descriptor */
1955 Status = SampCreateGroupSD(&Sd,
1956 &SdSize);
1957 if (!NT_SUCCESS(Status))
1958 {
1959 TRACE("SampCreateGroupSD failed (Status 0x%08lx)\n", Status);
1960 goto done;
1961 }
1962
1963 /* Get the fixed domain attributes */
1964 ulSize = sizeof(SAM_DOMAIN_FIXED_DATA);
1965 Status = SampGetObjectAttribute(DomainObject,
1966 L"F",
1967 NULL,
1968 (PVOID)&FixedDomainData,
1969 &ulSize);
1970 if (!NT_SUCCESS(Status))
1971 {
1972 TRACE("failed with status 0x%08lx\n", Status);
1973 goto done;
1974 }
1975
1976 /* Increment the NextRid attribute */
1977 ulRid = FixedDomainData.NextRid;
1978 FixedDomainData.NextRid++;
1979
1980 /* Store the fixed domain attributes */
1981 Status = SampSetObjectAttribute(DomainObject,
1982 L"F",
1983 REG_BINARY,
1984 &FixedDomainData,
1985 ulSize);
1986 if (!NT_SUCCESS(Status))
1987 {
1988 TRACE("failed with status 0x%08lx\n", Status);
1989 goto done;
1990 }
1991
1992 TRACE("RID: %lx\n", ulRid);
1993
1994 /* Convert the RID into a string (hex) */
1995 _swprintf(szRid, L"%08lX", ulRid);
1996
1997 /* Create the group object */
1998 Status = SampCreateDbObject(DomainObject,
1999 L"Groups",
2000 szRid,
2001 ulRid,
2002 SamDbGroupObject,
2003 DesiredAccess,
2004 &GroupObject);
2005 if (!NT_SUCCESS(Status))
2006 {
2007 TRACE("failed with status 0x%08lx\n", Status);
2008 goto done;
2009 }
2010
2011 /* Add the account name of the user object */
2012 Status = SampSetAccountNameInDomain(DomainObject,
2013 L"Groups",
2014 Name->Buffer,
2015 ulRid);
2016 if (!NT_SUCCESS(Status))
2017 {
2018 TRACE("failed with status 0x%08lx\n", Status);
2019 goto done;
2020 }
2021
2022 /* Initialize fixed user data */
2023 memset(&FixedGroupData, 0, sizeof(SAM_GROUP_FIXED_DATA));
2024 FixedGroupData.Version = 1;
2025 FixedGroupData.GroupId = ulRid;
2026
2027 /* Set fixed user data attribute */
2028 Status = SampSetObjectAttribute(GroupObject,
2029 L"F",
2030 REG_BINARY,
2031 (LPVOID)&FixedGroupData,
2032 sizeof(SAM_GROUP_FIXED_DATA));
2033 if (!NT_SUCCESS(Status))
2034 {
2035 TRACE("failed with status 0x%08lx\n", Status);
2036 goto done;
2037 }
2038
2039 /* Set the Name attribute */
2040 Status = SampSetObjectAttributeString(GroupObject,
2041 L"Name",
2042 Name);
2043 if (!NT_SUCCESS(Status))
2044 {
2045 TRACE("failed with status 0x%08lx\n", Status);
2046 goto done;
2047 }
2048
2049 /* Set the AdminComment attribute */
2050 Status = SampSetObjectAttributeString(GroupObject,
2051 L"AdminComment",
2052 NULL);
2053 if (!NT_SUCCESS(Status))
2054 {
2055 TRACE("failed with status 0x%08lx\n", Status);
2056 goto done;
2057 }
2058
2059 /* Set the SecDesc attribute*/
2060 Status = SampSetObjectAttribute(GroupObject,
2061 L"SecDesc",
2062 REG_BINARY,
2063 Sd,
2064 SdSize);
2065 if (!NT_SUCCESS(Status))
2066 {
2067 TRACE("failed with status 0x%08lx\n", Status);
2068 goto done;
2069 }
2070
2071 if (NT_SUCCESS(Status))
2072 {
2073 *GroupHandle = (SAMPR_HANDLE)GroupObject;
2074 *RelativeId = ulRid;
2075 }
2076
2077done:
2078 if (Sd != NULL)
2079 RtlFreeHeap(RtlGetProcessHeap(), 0, Sd);
2080
2081 RtlReleaseResource(&SampResource);
2082
2083 TRACE("returns with status 0x%08lx\n", Status);
2084
2085 return Status;
2086}
2087
2088
2089/* Function 11 */
2090NTSTATUS
2091NTAPI
2092SamrEnumerateGroupsInDomain(IN SAMPR_HANDLE DomainHandle,
2093 IN OUT unsigned long *EnumerationContext,
2094 OUT PSAMPR_ENUMERATION_BUFFER *Buffer,
2095 IN unsigned long PreferedMaximumLength,
2096 OUT unsigned long *CountReturned)
2097{
2098 PSAMPR_ENUMERATION_BUFFER EnumBuffer = NULL;
2099 PSAM_DB_OBJECT DomainObject;
2100 HANDLE GroupsKeyHandle = NULL;
2101 HANDLE NamesKeyHandle = NULL;
2102 WCHAR GroupName[64];
2103 ULONG EnumIndex;
2104 ULONG EnumCount = 0;
2105 ULONG RequiredLength = 0;
2106 ULONG NameLength;
2107 ULONG DataLength;
2108 ULONG Rid;
2109 ULONG i;
2110 BOOLEAN MoreEntries = FALSE;
2111 NTSTATUS Status;
2112
2113 TRACE("SamrEnumerateUsersInDomain(%p %p %p %lu %p)\n",
2114 DomainHandle, EnumerationContext, Buffer,
2115 PreferedMaximumLength, CountReturned);
2116
2117 RtlAcquireResourceShared(&SampResource,
2118 TRUE);
2119
2120 /* Validate the domain handle */
2121 Status = SampValidateDbObject(DomainHandle,
2122 SamDbDomainObject,
2123 DOMAIN_LIST_ACCOUNTS,
2124 &DomainObject);
2125 if (!NT_SUCCESS(Status))
2126 goto done;
2127
2128 Status = SampRegOpenKey(DomainObject->KeyHandle,
2129 L"Groups",
2130 KEY_READ,
2131 &GroupsKeyHandle);
2132 if (!NT_SUCCESS(Status))
2133 goto done;
2134
2135 Status = SampRegOpenKey(GroupsKeyHandle,
2136 L"Names",
2137 KEY_READ,
2138 &NamesKeyHandle);
2139 if (!NT_SUCCESS(Status))
2140 goto done;
2141
2142 TRACE("Part 1\n");
2143
2144 EnumIndex = *EnumerationContext;
2145
2146 while (TRUE)
2147 {
2148 NameLength = 64 * sizeof(WCHAR);
2149 Status = SampRegEnumerateValue(NamesKeyHandle,
2150 EnumIndex,
2151 GroupName,
2152 &NameLength,
2153 NULL,
2154 NULL,
2155 NULL);
2156 if (!NT_SUCCESS(Status))
2157 {
2158 if (Status == STATUS_NO_MORE_ENTRIES)
2159 Status = STATUS_SUCCESS;
2160 break;
2161 }
2162
2163 TRACE("EnumIndex: %lu\n", EnumIndex);
2164 TRACE("Group name: %S\n", GroupName);
2165 TRACE("Name length: %lu\n", NameLength);
2166
2167 if ((RequiredLength + NameLength + sizeof(UNICODE_NULL) + sizeof(SAMPR_RID_ENUMERATION)) > PreferedMaximumLength)
2168 {
2169 MoreEntries = TRUE;
2170 break;
2171 }
2172
2173 RequiredLength += (NameLength + sizeof(UNICODE_NULL) + sizeof(SAMPR_RID_ENUMERATION));
2174 EnumCount++;
2175
2176 EnumIndex++;
2177 }
2178
2179 TRACE("EnumCount: %lu\n", EnumCount);
2180 TRACE("RequiredLength: %lu\n", RequiredLength);
2181
2182 if (!NT_SUCCESS(Status))
2183 goto done;
2184
2185 EnumBuffer = midl_user_allocate(sizeof(SAMPR_ENUMERATION_BUFFER));
2186 if (EnumBuffer == NULL)
2187 {
2188 Status = STATUS_INSUFFICIENT_RESOURCES;
2189 goto done;
2190 }
2191
2192 EnumBuffer->EntriesRead = EnumCount;
2193 if (EnumCount == 0)
2194 {
2195 Status = STATUS_NO_MORE_ENTRIES;
2196 goto done;
2197 }
2198
2199 EnumBuffer->Buffer = midl_user_allocate(EnumCount * sizeof(SAMPR_RID_ENUMERATION));
2200 if (EnumBuffer->Buffer == NULL)
2201 {
2202 Status = STATUS_INSUFFICIENT_RESOURCES;
2203 goto done;
2204 }
2205
2206 TRACE("Part 2\n");
2207
2208 EnumIndex = *EnumerationContext;
2209 for (i = 0; i < EnumCount; i++, EnumIndex++)
2210 {
2211 NameLength = 64 * sizeof(WCHAR);
2212 DataLength = sizeof(ULONG);
2213 Status = SampRegEnumerateValue(NamesKeyHandle,
2214 EnumIndex,
2215 GroupName,
2216 &NameLength,
2217 NULL,
2218 &Rid,
2219 &DataLength);
2220 if (!NT_SUCCESS(Status))
2221 {
2222 if (Status == STATUS_NO_MORE_ENTRIES)
2223 Status = STATUS_SUCCESS;
2224 break;
2225 }
2226
2227 TRACE("EnumIndex: %lu\n", EnumIndex);
2228 TRACE("Group name: %S\n", GroupName);
2229 TRACE("Name length: %lu\n", NameLength);
2230 TRACE("RID: %lu\n", Rid);
2231
2232 EnumBuffer->Buffer[i].RelativeId = Rid;
2233
2234 EnumBuffer->Buffer[i].Name.Length = (USHORT)NameLength;
2235 EnumBuffer->Buffer[i].Name.MaximumLength = (USHORT)(NameLength + sizeof(UNICODE_NULL));
2236
2237/* FIXME: Disabled because of bugs in widl and rpcrt4 */
2238#if 0
2239 EnumBuffer->Buffer[i].Name.Buffer = midl_user_allocate(EnumBuffer->Buffer[i].Name.MaximumLength);
2240 if (EnumBuffer->Buffer[i].Name.Buffer == NULL)
2241 {
2242 Status = STATUS_INSUFFICIENT_RESOURCES;
2243 goto done;
2244 }
2245
2246 memcpy(EnumBuffer->Buffer[i].Name.Buffer,
2247 GroupName,
2248 EnumBuffer->Buffer[i].Name.Length);
2249#endif
2250 }
2251
2252done:
2253 if (NT_SUCCESS(Status))
2254 {
2255 *EnumerationContext += EnumCount;
2256 *Buffer = EnumBuffer;
2257 *CountReturned = EnumCount;
2258 }
2259 else
2260 {
2261 *EnumerationContext = 0;
2262 *Buffer = NULL;
2263 *CountReturned = 0;
2264
2265 if (EnumBuffer != NULL)
2266 {
2267 if (EnumBuffer->Buffer != NULL)
2268 {
2269 if (EnumBuffer->EntriesRead != 0)
2270 {
2271 for (i = 0; i < EnumBuffer->EntriesRead; i++)
2272 {
2273 if (EnumBuffer->Buffer[i].Name.Buffer != NULL)
2274 midl_user_free(EnumBuffer->Buffer[i].Name.Buffer);
2275 }
2276 }
2277
2278 midl_user_free(EnumBuffer->Buffer);
2279 }
2280
2281 midl_user_free(EnumBuffer);
2282 }
2283 }
2284
2285 SampRegCloseKey(&NamesKeyHandle);
2286 SampRegCloseKey(&GroupsKeyHandle);
2287
2288 if ((Status == STATUS_SUCCESS) && (MoreEntries != FALSE))
2289 Status = STATUS_MORE_ENTRIES;
2290
2291 RtlReleaseResource(&SampResource);
2292
2293 return Status;
2294}
2295
2296
2297/* Function 12 */
2298NTSTATUS
2299NTAPI
2300SamrCreateUserInDomain(IN SAMPR_HANDLE DomainHandle,
2301 IN PRPC_UNICODE_STRING Name,
2302 IN ACCESS_MASK DesiredAccess,
2303 OUT SAMPR_HANDLE *UserHandle,
2304 OUT unsigned long *RelativeId)
2305{
2306 SAM_DOMAIN_FIXED_DATA FixedDomainData;
2307 SAM_USER_FIXED_DATA FixedUserData;
2308 PSAM_DB_OBJECT DomainObject;
2309 PSAM_DB_OBJECT UserObject;
2310 GROUP_MEMBERSHIP GroupMembership;
2311 UCHAR LogonHours[23];
2312 ULONG ulSize;
2313 ULONG ulRid;
2314 WCHAR szRid[9];
2315 PSECURITY_DESCRIPTOR Sd = NULL;
2316 ULONG SdSize = 0;
2317 PSID UserSid = NULL;
2318 NTSTATUS Status;
2319
2320 TRACE("SamrCreateUserInDomain(%p %p %lx %p %p)\n",
2321 DomainHandle, Name, DesiredAccess, UserHandle, RelativeId);
2322
2323 if (Name == NULL ||
2324 Name->Length == 0 ||
2325 Name->Buffer == NULL ||
2326 UserHandle == NULL ||
2327 RelativeId == NULL)
2328 return STATUS_INVALID_PARAMETER;
2329
2330 /* Map generic access rights */
2331 RtlMapGenericMask(&DesiredAccess,
2332 &UserMapping);
2333
2334 RtlAcquireResourceExclusive(&SampResource,
2335 TRUE);
2336
2337 /* Validate the domain handle */
2338 Status = SampValidateDbObject(DomainHandle,
2339 SamDbDomainObject,
2340 DOMAIN_CREATE_USER,
2341 &DomainObject);
2342 if (!NT_SUCCESS(Status))
2343 {
2344 TRACE("failed with status 0x%08lx\n", Status);
2345 goto done;
2346 }
2347
2348 /* Check the user account name */
2349 Status = SampCheckAccountName(Name, 20);
2350 if (!NT_SUCCESS(Status))
2351 {
2352 TRACE("SampCheckAccountName failed (Status 0x%08lx)\n", Status);
2353 goto done;
2354 }
2355
2356 /* Check if the user name already exists in the domain */
2357 Status = SampCheckAccountNameInDomain(DomainObject,
2358 Name->Buffer);
2359 if (!NT_SUCCESS(Status))
2360 {
2361 TRACE("User name \'%S\' already exists in domain (Status 0x%08lx)\n",
2362 Name->Buffer, Status);
2363 goto done;
2364 }
2365
2366 /* Get the fixed domain attributes */
2367 ulSize = sizeof(SAM_DOMAIN_FIXED_DATA);
2368 Status = SampGetObjectAttribute(DomainObject,
2369 L"F",
2370 NULL,
2371 (PVOID)&FixedDomainData,
2372 &ulSize);
2373 if (!NT_SUCCESS(Status))
2374 {
2375 TRACE("failed with status 0x%08lx\n", Status);
2376 goto done;
2377 }
2378
2379 /* Increment the NextRid attribute */
2380 ulRid = FixedDomainData.NextRid;
2381 FixedDomainData.NextRid++;
2382
2383 TRACE("RID: %lx\n", ulRid);
2384
2385 /* Create the user SID */
2386 Status = SampCreateAccountSid(DomainObject,
2387 ulRid,
2388 &UserSid);
2389 if (!NT_SUCCESS(Status))
2390 {
2391 TRACE("SampCreateAccountSid failed (Status 0x%08lx)\n", Status);
2392 goto done;
2393 }
2394
2395 /* Create the security descriptor */
2396 Status = SampCreateUserSD(UserSid,
2397 &Sd,
2398 &SdSize);
2399 if (!NT_SUCCESS(Status))
2400 {
2401 TRACE("SampCreateUserSD failed (Status 0x%08lx)\n", Status);
2402 goto done;
2403 }
2404
2405 /* Store the fixed domain attributes */
2406 Status = SampSetObjectAttribute(DomainObject,
2407 L"F",
2408 REG_BINARY,
2409 &FixedDomainData,
2410 ulSize);
2411 if (!NT_SUCCESS(Status))
2412 {
2413 TRACE("failed with status 0x%08lx\n", Status);
2414 goto done;
2415 }
2416
2417 /* Convert the RID into a string (hex) */
2418 _swprintf(szRid, L"%08lX", ulRid);
2419
2420 /* Create the user object */
2421 Status = SampCreateDbObject(DomainObject,
2422 L"Users",
2423 szRid,
2424 ulRid,
2425 SamDbUserObject,
2426 DesiredAccess,
2427 &UserObject);
2428 if (!NT_SUCCESS(Status))
2429 {
2430 TRACE("failed with status 0x%08lx\n", Status);
2431 goto done;
2432 }
2433
2434 /* Add the account name for the user object */
2435 Status = SampSetAccountNameInDomain(DomainObject,
2436 L"Users",
2437 Name->Buffer,
2438 ulRid);
2439 if (!NT_SUCCESS(Status))
2440 {
2441 TRACE("failed with status 0x%08lx\n", Status);
2442 goto done;
2443 }
2444
2445 /* Initialize fixed user data */
2446 memset(&FixedUserData, 0, sizeof(SAM_USER_FIXED_DATA));
2447 FixedUserData.Version = 1;
2448 FixedUserData.Reserved = 0;
2449 FixedUserData.LastLogon.QuadPart = 0;
2450 FixedUserData.LastLogoff.QuadPart = 0;
2451 FixedUserData.PasswordLastSet.QuadPart = 0;
2452 FixedUserData.AccountExpires.QuadPart = MAXLONGLONG;
2453 FixedUserData.LastBadPasswordTime.QuadPart = 0;
2454 FixedUserData.UserId = ulRid;
2455 FixedUserData.PrimaryGroupId = DOMAIN_GROUP_RID_USERS;
2456 FixedUserData.UserAccountControl = USER_ACCOUNT_DISABLED |
2457 USER_PASSWORD_NOT_REQUIRED |
2458 USER_NORMAL_ACCOUNT;
2459 FixedUserData.CountryCode = 0;
2460 FixedUserData.CodePage = 0;
2461 FixedUserData.BadPasswordCount = 0;
2462 FixedUserData.LogonCount = 0;
2463 FixedUserData.AdminCount = 0;
2464 FixedUserData.OperatorCount = 0;
2465
2466 /* Set fixed user data attribute */
2467 Status = SampSetObjectAttribute(UserObject,
2468 L"F",
2469 REG_BINARY,
2470 (LPVOID)&FixedUserData,
2471 sizeof(SAM_USER_FIXED_DATA));
2472 if (!NT_SUCCESS(Status))
2473 {
2474 TRACE("failed with status 0x%08lx\n", Status);
2475 goto done;
2476 }
2477
2478 /* Set the Name attribute */
2479 Status = SampSetObjectAttributeString(UserObject,
2480 L"Name",
2481 Name);
2482 if (!NT_SUCCESS(Status))
2483 {
2484 TRACE("failed with status 0x%08lx\n", Status);
2485 goto done;
2486 }
2487
2488 /* Set the FullName attribute */
2489 Status = SampSetObjectAttributeString(UserObject,
2490 L"FullName",
2491 NULL);
2492 if (!NT_SUCCESS(Status))
2493 {
2494 TRACE("failed with status 0x%08lx\n", Status);
2495 goto done;
2496 }
2497
2498 /* Set the HomeDirectory attribute */
2499 Status = SampSetObjectAttributeString(UserObject,
2500 L"HomeDirectory",
2501 NULL);
2502 if (!NT_SUCCESS(Status))
2503 {
2504 TRACE("failed with status 0x%08lx\n", Status);
2505 goto done;
2506 }
2507
2508 /* Set the HomeDirectoryDrive attribute */
2509 Status = SampSetObjectAttributeString(UserObject,
2510 L"HomeDirectoryDrive",
2511 NULL);
2512 if (!NT_SUCCESS(Status))
2513 {
2514 TRACE("failed with status 0x%08lx\n", Status);
2515 goto done;
2516 }
2517
2518 /* Set the ScriptPath attribute */
2519 Status = SampSetObjectAttributeString(UserObject,
2520 L"ScriptPath",
2521 NULL);
2522 if (!NT_SUCCESS(Status))
2523 {
2524 TRACE("failed with status 0x%08lx\n", Status);
2525 goto done;
2526 }
2527
2528 /* Set the ProfilePath attribute */
2529 Status = SampSetObjectAttributeString(UserObject,
2530 L"ProfilePath",
2531 NULL);
2532 if (!NT_SUCCESS(Status))
2533 {
2534 TRACE("failed with status 0x%08lx\n", Status);
2535 goto done;
2536 }
2537
2538 /* Set the AdminComment attribute */
2539 Status = SampSetObjectAttributeString(UserObject,
2540 L"AdminComment",
2541 NULL);
2542 if (!NT_SUCCESS(Status))
2543 {
2544 TRACE("failed with status 0x%08lx\n", Status);
2545 goto done;
2546 }
2547
2548 /* Set the UserComment attribute */
2549 Status = SampSetObjectAttributeString(UserObject,
2550 L"UserComment",
2551 NULL);
2552 if (!NT_SUCCESS(Status))
2553 {
2554 TRACE("failed with status 0x%08lx\n", Status);
2555 goto done;
2556 }
2557
2558 /* Set the WorkStations attribute */
2559 Status = SampSetObjectAttributeString(UserObject,
2560 L"WorkStations",
2561 NULL);
2562 if (!NT_SUCCESS(Status))
2563 {
2564 TRACE("failed with status 0x%08lx\n", Status);
2565 goto done;
2566 }
2567
2568 /* Set the Parameters attribute */
2569 Status = SampSetObjectAttributeString(UserObject,
2570 L"Parameters",
2571 NULL);
2572 if (!NT_SUCCESS(Status))
2573 {
2574 TRACE("failed with status 0x%08lx\n", Status);
2575 goto done;
2576 }
2577
2578 /* Set LogonHours attribute*/
2579 *((PUSHORT)LogonHours) = 168;
2580 memset(&(LogonHours[2]), 0xff, 21);
2581
2582 Status = SampSetObjectAttribute(UserObject,
2583 L"LogonHours",
2584 REG_BINARY,
2585 &LogonHours,
2586 sizeof(LogonHours));
2587 if (!NT_SUCCESS(Status))
2588 {
2589 TRACE("failed with status 0x%08lx\n", Status);
2590 goto done;
2591 }
2592
2593 /* Set Groups attribute*/
2594 GroupMembership.RelativeId = DOMAIN_GROUP_RID_USERS;
2595 GroupMembership.Attributes = SE_GROUP_MANDATORY |
2596 SE_GROUP_ENABLED |
2597 SE_GROUP_ENABLED_BY_DEFAULT;
2598
2599 Status = SampSetObjectAttribute(UserObject,
2600 L"Groups",
2601 REG_BINARY,
2602 &GroupMembership,
2603 sizeof(GROUP_MEMBERSHIP));
2604 if (!NT_SUCCESS(Status))
2605 {
2606 TRACE("failed with status 0x%08lx\n", Status);
2607 goto done;
2608 }
2609
2610 /* Set LMPwd attribute*/
2611 Status = SampSetObjectAttribute(UserObject,
2612 L"LMPwd",
2613 REG_BINARY,
2614 &EmptyLmHash,
2615 sizeof(ENCRYPTED_LM_OWF_PASSWORD));
2616 if (!NT_SUCCESS(Status))
2617 {
2618 TRACE("failed with status 0x%08lx\n", Status);
2619 goto done;
2620 }
2621
2622 /* Set NTPwd attribute*/
2623 Status = SampSetObjectAttribute(UserObject,
2624 L"NTPwd",
2625 REG_BINARY,
2626 &EmptyNtHash,
2627 sizeof(ENCRYPTED_NT_OWF_PASSWORD));
2628 if (!NT_SUCCESS(Status))
2629 {
2630 TRACE("failed with status 0x%08lx\n", Status);
2631 goto done;
2632 }
2633
2634 /* Set LMPwdHistory attribute*/
2635 Status = SampSetObjectAttribute(UserObject,
2636 L"LMPwdHistory",
2637 REG_BINARY,
2638 NULL,
2639 0);
2640 if (!NT_SUCCESS(Status))
2641 {
2642 TRACE("failed with status 0x%08lx\n", Status);
2643 goto done;
2644 }
2645
2646 /* Set NTPwdHistory attribute*/
2647 Status = SampSetObjectAttribute(UserObject,
2648 L"NTPwdHistory",
2649 REG_BINARY,
2650 NULL,
2651 0);
2652 if (!NT_SUCCESS(Status))
2653 {
2654 TRACE("failed with status 0x%08lx\n", Status);
2655 goto done;
2656 }
2657
2658 /* Set the PrivateData attribute */
2659 Status = SampSetObjectAttributeString(UserObject,
2660 L"PrivateData",
2661 NULL);
2662 if (!NT_SUCCESS(Status))
2663 {
2664 TRACE("failed with status 0x%08lx\n", Status);
2665 goto done;
2666 }
2667
2668 /* Set the SecDesc attribute*/
2669 Status = SampSetObjectAttribute(UserObject,
2670 L"SecDesc",
2671 REG_BINARY,
2672 Sd,
2673 SdSize);
2674 if (!NT_SUCCESS(Status))
2675 {
2676 TRACE("failed with status 0x%08lx\n", Status);
2677 goto done;
2678 }
2679
2680 if (NT_SUCCESS(Status))
2681 {
2682 *UserHandle = (SAMPR_HANDLE)UserObject;
2683 *RelativeId = ulRid;
2684 }
2685
2686done:
2687 if (Sd != NULL)
2688 RtlFreeHeap(RtlGetProcessHeap(), 0, Sd);
2689
2690 if (UserSid != NULL)
2691 RtlFreeHeap(RtlGetProcessHeap(), 0, UserSid);
2692
2693 RtlReleaseResource(&SampResource);
2694
2695 TRACE("returns with status 0x%08lx\n", Status);
2696
2697 return Status;
2698}
2699
2700
2701/* Function 13 */
2702NTSTATUS
2703NTAPI
2704SamrEnumerateUsersInDomain(IN SAMPR_HANDLE DomainHandle,
2705 IN OUT unsigned long *EnumerationContext,
2706 IN unsigned long UserAccountControl,
2707 OUT PSAMPR_ENUMERATION_BUFFER *Buffer,
2708 IN unsigned long PreferedMaximumLength,
2709 OUT unsigned long *CountReturned)
2710{
2711 PSAMPR_ENUMERATION_BUFFER EnumBuffer = NULL;
2712 PSAM_DB_OBJECT DomainObject;
2713 HANDLE UsersKeyHandle = NULL;
2714 HANDLE NamesKeyHandle = NULL;
2715 WCHAR UserName[64];
2716 ULONG EnumIndex;
2717 ULONG EnumCount = 0;
2718 ULONG RequiredLength = 0;
2719 ULONG NameLength;
2720 ULONG DataLength;
2721 ULONG Rid;
2722 ULONG i;
2723 BOOLEAN MoreEntries = FALSE;
2724 NTSTATUS Status;
2725
2726 TRACE("SamrEnumerateUsersInDomain(%p %p %lx %p %lu %p)\n",
2727 DomainHandle, EnumerationContext, UserAccountControl, Buffer,
2728 PreferedMaximumLength, CountReturned);
2729
2730 RtlAcquireResourceShared(&SampResource,
2731 TRUE);
2732
2733 /* Validate the domain handle */
2734 Status = SampValidateDbObject(DomainHandle,
2735 SamDbDomainObject,
2736 DOMAIN_LIST_ACCOUNTS,
2737 &DomainObject);
2738 if (!NT_SUCCESS(Status))
2739 goto done;
2740
2741 Status = SampRegOpenKey(DomainObject->KeyHandle,
2742 L"Users",
2743 KEY_READ,
2744 &UsersKeyHandle);
2745 if (!NT_SUCCESS(Status))
2746 goto done;
2747
2748 Status = SampRegOpenKey(UsersKeyHandle,
2749 L"Names",
2750 KEY_READ,
2751 &NamesKeyHandle);
2752 if (!NT_SUCCESS(Status))
2753 goto done;
2754
2755 TRACE("Part 1\n");
2756
2757 EnumIndex = *EnumerationContext;
2758
2759 while (TRUE)
2760 {
2761 NameLength = 64 * sizeof(WCHAR);
2762 Status = SampRegEnumerateValue(NamesKeyHandle,
2763 EnumIndex,
2764 UserName,
2765 &NameLength,
2766 NULL,
2767 NULL,
2768 NULL);
2769 if (!NT_SUCCESS(Status))
2770 {
2771 if (Status == STATUS_NO_MORE_ENTRIES)
2772 Status = STATUS_SUCCESS;
2773 break;
2774 }
2775
2776 TRACE("EnumIndex: %lu\n", EnumIndex);
2777 TRACE("User name: %S\n", UserName);
2778 TRACE("Name length: %lu\n", NameLength);
2779
2780 if ((RequiredLength + NameLength + sizeof(UNICODE_NULL) + sizeof(SAMPR_RID_ENUMERATION)) > PreferedMaximumLength)
2781 {
2782 MoreEntries = TRUE;
2783 break;
2784 }
2785
2786 RequiredLength += (NameLength + sizeof(UNICODE_NULL) + sizeof(SAMPR_RID_ENUMERATION));
2787 EnumCount++;
2788
2789 EnumIndex++;
2790 }
2791
2792 TRACE("EnumCount: %lu\n", EnumCount);
2793 TRACE("RequiredLength: %lu\n", RequiredLength);
2794
2795 if (!NT_SUCCESS(Status))
2796 goto done;
2797
2798 EnumBuffer = midl_user_allocate(sizeof(SAMPR_ENUMERATION_BUFFER));
2799 if (EnumBuffer == NULL)
2800 {
2801 Status = STATUS_INSUFFICIENT_RESOURCES;
2802 goto done;
2803 }
2804
2805 EnumBuffer->EntriesRead = EnumCount;
2806 if (EnumCount == 0)
2807 {
2808 Status = STATUS_NO_MORE_ENTRIES;
2809 goto done;
2810 }
2811
2812 EnumBuffer->Buffer = midl_user_allocate(EnumCount * sizeof(SAMPR_RID_ENUMERATION));
2813 if (EnumBuffer->Buffer == NULL)
2814 {
2815 Status = STATUS_INSUFFICIENT_RESOURCES;
2816 goto done;
2817 }
2818
2819 TRACE("Part 2\n");
2820
2821 EnumIndex = *EnumerationContext;
2822 for (i = 0; i < EnumCount; i++, EnumIndex++)
2823 {
2824 NameLength = 64 * sizeof(WCHAR);
2825 DataLength = sizeof(ULONG);
2826 Status = SampRegEnumerateValue(NamesKeyHandle,
2827 EnumIndex,
2828 UserName,
2829 &NameLength,
2830 NULL,
2831 &Rid,
2832 &DataLength);
2833 if (!NT_SUCCESS(Status))
2834 {
2835 if (Status == STATUS_NO_MORE_ENTRIES)
2836 Status = STATUS_SUCCESS;
2837 break;
2838 }
2839
2840 TRACE("EnumIndex: %lu\n", EnumIndex);
2841 TRACE("User name: %S\n", UserName);
2842 TRACE("Name length: %lu\n", NameLength);
2843 TRACE("RID: %lu\n", Rid);
2844
2845 EnumBuffer->Buffer[i].RelativeId = Rid;
2846
2847 EnumBuffer->Buffer[i].Name.Length = (USHORT)NameLength;
2848 EnumBuffer->Buffer[i].Name.MaximumLength = (USHORT)(NameLength + sizeof(UNICODE_NULL));
2849
2850/* FIXME: Disabled because of bugs in widl and rpcrt4 */
2851#if 0
2852 EnumBuffer->Buffer[i].Name.Buffer = midl_user_allocate(EnumBuffer->Buffer[i].Name.MaximumLength);
2853 if (EnumBuffer->Buffer[i].Name.Buffer == NULL)
2854 {
2855 Status = STATUS_INSUFFICIENT_RESOURCES;
2856 goto done;
2857 }
2858
2859 memcpy(EnumBuffer->Buffer[i].Name.Buffer,
2860 UserName,
2861 EnumBuffer->Buffer[i].Name.Length);
2862#endif
2863 }
2864
2865done:
2866 if (NT_SUCCESS(Status))
2867 {
2868 *EnumerationContext += EnumCount;
2869 *Buffer = EnumBuffer;
2870 *CountReturned = EnumCount;
2871 }
2872 else
2873 {
2874 *EnumerationContext = 0;
2875 *Buffer = NULL;
2876 *CountReturned = 0;
2877
2878 if (EnumBuffer != NULL)
2879 {
2880 if (EnumBuffer->Buffer != NULL)
2881 {
2882 if (EnumBuffer->EntriesRead != 0)
2883 {
2884 for (i = 0; i < EnumBuffer->EntriesRead; i++)
2885 {
2886 if (EnumBuffer->Buffer[i].Name.Buffer != NULL)
2887 midl_user_free(EnumBuffer->Buffer[i].Name.Buffer);
2888 }
2889 }
2890
2891 midl_user_free(EnumBuffer->Buffer);
2892 }
2893
2894 midl_user_free(EnumBuffer);
2895 }
2896 }
2897
2898 SampRegCloseKey(&NamesKeyHandle);
2899 SampRegCloseKey(&UsersKeyHandle);
2900
2901 if ((Status == STATUS_SUCCESS) && (MoreEntries != FALSE))
2902 Status = STATUS_MORE_ENTRIES;
2903
2904 RtlReleaseResource(&SampResource);
2905
2906 return Status;
2907}
2908
2909
2910/* Function 14 */
2911NTSTATUS
2912NTAPI
2913SamrCreateAliasInDomain(IN SAMPR_HANDLE DomainHandle,
2914 IN PRPC_UNICODE_STRING AccountName,
2915 IN ACCESS_MASK DesiredAccess,
2916 OUT SAMPR_HANDLE *AliasHandle,
2917 OUT unsigned long *RelativeId)
2918{
2919 SAM_DOMAIN_FIXED_DATA FixedDomainData;
2920 PSAM_DB_OBJECT DomainObject;
2921 PSAM_DB_OBJECT AliasObject;
2922 PSECURITY_DESCRIPTOR Sd = NULL;
2923 ULONG SdSize = 0;
2924 ULONG ulSize;
2925 ULONG ulRid;
2926 WCHAR szRid[9];
2927 NTSTATUS Status;
2928
2929 TRACE("SamrCreateAliasInDomain(%p %p %lx %p %p)\n",
2930 DomainHandle, AccountName, DesiredAccess, AliasHandle, RelativeId);
2931
2932 /* Map generic access rights */
2933 RtlMapGenericMask(&DesiredAccess,
2934 &AliasMapping);
2935
2936 RtlAcquireResourceExclusive(&SampResource,
2937 TRUE);
2938
2939 /* Validate the domain handle */
2940 Status = SampValidateDbObject(DomainHandle,
2941 SamDbDomainObject,
2942 DOMAIN_CREATE_ALIAS,
2943 &DomainObject);
2944 if (!NT_SUCCESS(Status))
2945 {
2946 TRACE("failed with status 0x%08lx\n", Status);
2947 goto done;
2948 }
2949
2950 /* Check the alias account name */
2951 Status = SampCheckAccountName(AccountName, 256);
2952 if (!NT_SUCCESS(Status))
2953 {
2954 TRACE("SampCheckAccountName failed (Status 0x%08lx)\n", Status);
2955 goto done;
2956 }
2957
2958 /* Check if the alias name already exists in the domain */
2959 Status = SampCheckAccountNameInDomain(DomainObject,
2960 AccountName->Buffer);
2961 if (!NT_SUCCESS(Status))
2962 {
2963 TRACE("Alias name \'%S\' already exists in domain (Status 0x%08lx)\n",
2964 AccountName->Buffer, Status);
2965 goto done;
2966 }
2967
2968 /* Create the security descriptor */
2969 Status = SampCreateAliasSD(&Sd,
2970 &SdSize);
2971 if (!NT_SUCCESS(Status))
2972 {
2973 TRACE("SampCreateAliasSD failed (Status 0x%08lx)\n", Status);
2974 goto done;
2975 }
2976
2977 /* Get the fixed domain attributes */
2978 ulSize = sizeof(SAM_DOMAIN_FIXED_DATA);
2979 Status = SampGetObjectAttribute(DomainObject,
2980 L"F",
2981 NULL,
2982 (PVOID)&FixedDomainData,
2983 &ulSize);
2984 if (!NT_SUCCESS(Status))
2985 {
2986 TRACE("failed with status 0x%08lx\n", Status);
2987 goto done;
2988 }
2989
2990 /* Increment the NextRid attribute */
2991 ulRid = FixedDomainData.NextRid;
2992 FixedDomainData.NextRid++;
2993
2994 /* Store the fixed domain attributes */
2995 Status = SampSetObjectAttribute(DomainObject,
2996 L"F",
2997 REG_BINARY,
2998 &FixedDomainData,
2999 ulSize);
3000 if (!NT_SUCCESS(Status))
3001 {
3002 TRACE("failed with status 0x%08lx\n", Status);
3003 goto done;
3004 }
3005
3006 TRACE("RID: %lx\n", ulRid);
3007
3008 /* Convert the RID into a string (hex) */
3009 _swprintf(szRid, L"%08lX", ulRid);
3010
3011 /* Create the alias object */
3012 Status = SampCreateDbObject(DomainObject,
3013 L"Aliases",
3014 szRid,
3015 ulRid,
3016 SamDbAliasObject,
3017 DesiredAccess,
3018 &AliasObject);
3019 if (!NT_SUCCESS(Status))
3020 {
3021 TRACE("failed with status 0x%08lx\n", Status);
3022 goto done;
3023 }
3024
3025 /* Add the account name for the alias object */
3026 Status = SampSetAccountNameInDomain(DomainObject,
3027 L"Aliases",
3028 AccountName->Buffer,
3029 ulRid);
3030 if (!NT_SUCCESS(Status))
3031 {
3032 TRACE("failed with status 0x%08lx\n", Status);
3033 goto done;
3034 }
3035
3036 /* Set the Name attribute */
3037 Status = SampSetObjectAttributeString(AliasObject,
3038 L"Name",
3039 AccountName);
3040 if (!NT_SUCCESS(Status))
3041 {
3042 TRACE("failed with status 0x%08lx\n", Status);
3043 goto done;
3044 }
3045
3046 /* Set the Description attribute */
3047 Status = SampSetObjectAttributeString(AliasObject,
3048 L"Description",
3049 NULL);
3050 if (!NT_SUCCESS(Status))
3051 {
3052 TRACE("failed with status 0x%08lx\n", Status);
3053 goto done;
3054 }
3055
3056 /* Set the SecDesc attribute*/
3057 Status = SampSetObjectAttribute(AliasObject,
3058 L"SecDesc",
3059 REG_BINARY,
3060 Sd,
3061 SdSize);
3062 if (!NT_SUCCESS(Status))
3063 {
3064 TRACE("failed with status 0x%08lx\n", Status);
3065 goto done;
3066 }
3067
3068 if (NT_SUCCESS(Status))
3069 {
3070 *AliasHandle = (SAMPR_HANDLE)AliasObject;
3071 *RelativeId = ulRid;
3072 }
3073
3074done:
3075 if (Sd != NULL)
3076 RtlFreeHeap(RtlGetProcessHeap(), 0, Sd);
3077
3078 RtlReleaseResource(&SampResource);
3079
3080 TRACE("returns with status 0x%08lx\n", Status);
3081
3082 return Status;
3083}
3084
3085
3086/* Function 15 */
3087NTSTATUS
3088NTAPI
3089SamrEnumerateAliasesInDomain(IN SAMPR_HANDLE DomainHandle,
3090 IN OUT unsigned long *EnumerationContext,
3091 OUT PSAMPR_ENUMERATION_BUFFER *Buffer,
3092 IN unsigned long PreferedMaximumLength,
3093 OUT unsigned long *CountReturned)
3094{
3095 PSAMPR_ENUMERATION_BUFFER EnumBuffer = NULL;
3096 PSAM_DB_OBJECT DomainObject;
3097 HANDLE AliasesKeyHandle = NULL;
3098 HANDLE NamesKeyHandle = NULL;
3099 WCHAR AliasName[64];
3100 ULONG EnumIndex;
3101 ULONG EnumCount = 0;
3102 ULONG RequiredLength = 0;
3103 ULONG NameLength;
3104 ULONG DataLength;
3105 ULONG Rid;
3106 ULONG i;
3107 BOOLEAN MoreEntries = FALSE;
3108 NTSTATUS Status;
3109
3110 TRACE("SamrEnumerateAliasesInDomain(%p %p %p %lu %p)\n",
3111 DomainHandle, EnumerationContext, Buffer,
3112 PreferedMaximumLength, CountReturned);
3113
3114 RtlAcquireResourceShared(&SampResource,
3115 TRUE);
3116
3117 /* Validate the domain handle */
3118 Status = SampValidateDbObject(DomainHandle,
3119 SamDbDomainObject,
3120 DOMAIN_LIST_ACCOUNTS,
3121 &DomainObject);
3122 if (!NT_SUCCESS(Status))
3123 goto done;
3124
3125 Status = SampRegOpenKey(DomainObject->KeyHandle,
3126 L"Aliases",
3127 KEY_READ,
3128 &AliasesKeyHandle);
3129 if (!NT_SUCCESS(Status))
3130 goto done;
3131
3132 Status = SampRegOpenKey(AliasesKeyHandle,
3133 L"Names",
3134 KEY_READ,
3135 &NamesKeyHandle);
3136 if (!NT_SUCCESS(Status))
3137 goto done;
3138
3139 TRACE("Part 1\n");
3140
3141 EnumIndex = *EnumerationContext;
3142
3143 while (TRUE)
3144 {
3145 NameLength = 64 * sizeof(WCHAR);
3146 Status = SampRegEnumerateValue(NamesKeyHandle,
3147 EnumIndex,
3148 AliasName,
3149 &NameLength,
3150 NULL,
3151 NULL,
3152 NULL);
3153 if (!NT_SUCCESS(Status))
3154 {
3155 if (Status == STATUS_NO_MORE_ENTRIES)
3156 Status = STATUS_SUCCESS;
3157 break;
3158 }
3159
3160 TRACE("EnumIndex: %lu\n", EnumIndex);
3161 TRACE("Alias name: %S\n", AliasName);
3162 TRACE("Name length: %lu\n", NameLength);
3163
3164 if ((RequiredLength + NameLength + sizeof(UNICODE_NULL) + sizeof(SAMPR_RID_ENUMERATION)) > PreferedMaximumLength)
3165 {
3166 MoreEntries = TRUE;
3167 break;
3168 }
3169
3170 RequiredLength += (NameLength + sizeof(UNICODE_NULL) + sizeof(SAMPR_RID_ENUMERATION));
3171 EnumCount++;
3172
3173 EnumIndex++;
3174 }
3175
3176 TRACE("EnumCount: %lu\n", EnumCount);
3177 TRACE("RequiredLength: %lu\n", RequiredLength);
3178
3179 if (!NT_SUCCESS(Status))
3180 goto done;
3181
3182 EnumBuffer = midl_user_allocate(sizeof(SAMPR_ENUMERATION_BUFFER));
3183 if (EnumBuffer == NULL)
3184 {
3185 Status = STATUS_INSUFFICIENT_RESOURCES;
3186 goto done;
3187 }
3188
3189 EnumBuffer->EntriesRead = EnumCount;
3190 if (EnumCount == 0)
3191 {
3192 Status = STATUS_NO_MORE_ENTRIES;
3193 goto done;
3194 }
3195
3196 EnumBuffer->Buffer = midl_user_allocate(EnumCount * sizeof(SAMPR_RID_ENUMERATION));
3197 if (EnumBuffer->Buffer == NULL)
3198 {
3199 Status = STATUS_INSUFFICIENT_RESOURCES;
3200 goto done;
3201 }
3202
3203 TRACE("Part 2\n");
3204
3205 EnumIndex = *EnumerationContext;
3206 for (i = 0; i < EnumCount; i++, EnumIndex++)
3207 {
3208 NameLength = 64 * sizeof(WCHAR);
3209 DataLength = sizeof(ULONG);
3210 Status = SampRegEnumerateValue(NamesKeyHandle,
3211 EnumIndex,
3212 AliasName,
3213 &NameLength,
3214 NULL,
3215 &Rid,
3216 &DataLength);
3217 if (!NT_SUCCESS(Status))
3218 {
3219 if (Status == STATUS_NO_MORE_ENTRIES)
3220 Status = STATUS_SUCCESS;
3221 break;
3222 }
3223
3224 TRACE("EnumIndex: %lu\n", EnumIndex);
3225 TRACE("Alias name: %S\n", AliasName);
3226 TRACE("Name length: %lu\n", NameLength);
3227 TRACE("RID: %lu\n", Rid);
3228
3229 EnumBuffer->Buffer[i].RelativeId = Rid;
3230
3231 EnumBuffer->Buffer[i].Name.Length = (USHORT)NameLength;
3232 EnumBuffer->Buffer[i].Name.MaximumLength = (USHORT)(NameLength + sizeof(UNICODE_NULL));
3233
3234/* FIXME: Disabled because of bugs in widl and rpcrt4 */
3235#if 0
3236 EnumBuffer->Buffer[i].Name.Buffer = midl_user_allocate(EnumBuffer->Buffer[i].Name.MaximumLength);
3237 if (EnumBuffer->Buffer[i].Name.Buffer == NULL)
3238 {
3239 Status = STATUS_INSUFFICIENT_RESOURCES;
3240 goto done;
3241 }
3242
3243 memcpy(EnumBuffer->Buffer[i].Name.Buffer,
3244 AliasName,
3245 EnumBuffer->Buffer[i].Name.Length);
3246#endif
3247 }
3248
3249done:
3250 if (NT_SUCCESS(Status))
3251 {
3252 *EnumerationContext += EnumCount;
3253 *Buffer = EnumBuffer;
3254 *CountReturned = EnumCount;
3255 }
3256 else
3257 {
3258 *EnumerationContext = 0;
3259 *Buffer = NULL;
3260 *CountReturned = 0;
3261
3262 if (EnumBuffer != NULL)
3263 {
3264 if (EnumBuffer->Buffer != NULL)
3265 {
3266 if (EnumBuffer->EntriesRead != 0)
3267 {
3268 for (i = 0; i < EnumBuffer->EntriesRead; i++)
3269 {
3270 if (EnumBuffer->Buffer[i].Name.Buffer != NULL)
3271 midl_user_free(EnumBuffer->Buffer[i].Name.Buffer);
3272 }
3273 }
3274
3275 midl_user_free(EnumBuffer->Buffer);
3276 }
3277
3278 midl_user_free(EnumBuffer);
3279 }
3280 }
3281
3282 SampRegCloseKey(&NamesKeyHandle);
3283 SampRegCloseKey(&AliasesKeyHandle);
3284
3285 if ((Status == STATUS_SUCCESS) && (MoreEntries != FALSE))
3286 Status = STATUS_MORE_ENTRIES;
3287
3288 RtlReleaseResource(&SampResource);
3289
3290 return Status;
3291}
3292
3293
3294/* Function 16 */
3295NTSTATUS
3296NTAPI
3297SamrGetAliasMembership(IN SAMPR_HANDLE DomainHandle,
3298 IN PSAMPR_PSID_ARRAY SidArray,
3299 OUT PSAMPR_ULONG_ARRAY Membership)
3300{
3301 PSAM_DB_OBJECT DomainObject;
3302 HANDLE AliasesKeyHandle = NULL;
3303 HANDLE MembersKeyHandle = NULL;
3304 HANDLE MemberKeyHandle = NULL;
3305 LPWSTR MemberSidString = NULL;
3306 PULONG RidArray = NULL;
3307 ULONG MaxSidCount = 0;
3308 ULONG ValueCount;
3309 ULONG DataLength;
3310 ULONG i, j;
3311 ULONG RidIndex;
3312 NTSTATUS Status;
3313 WCHAR NameBuffer[9];
3314
3315 TRACE("SamrGetAliasMembership(%p %p %p)\n",
3316 DomainHandle, SidArray, Membership);
3317
3318 RtlAcquireResourceShared(&SampResource,
3319 TRUE);
3320
3321 /* Validate the domain handle */
3322 Status = SampValidateDbObject(DomainHandle,
3323 SamDbDomainObject,
3324 DOMAIN_GET_ALIAS_MEMBERSHIP,
3325 &DomainObject);
3326 if (!NT_SUCCESS(Status))
3327 goto done;
3328
3329 Status = SampRegOpenKey(DomainObject->KeyHandle,
3330 L"Aliases",
3331 KEY_READ,
3332 &AliasesKeyHandle);
3333 TRACE("SampRegOpenKey returned %08lX\n", Status);
3334 if (!NT_SUCCESS(Status))
3335 goto done;
3336
3337 Status = SampRegOpenKey(AliasesKeyHandle,
3338 L"Members",
3339 KEY_READ,
3340 &MembersKeyHandle);
3341 TRACE("SampRegOpenKey returned %08lX\n", Status);
3342
3343 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
3344 {
3345 Status = STATUS_SUCCESS;
3346 goto done;
3347 }
3348
3349 if (!NT_SUCCESS(Status))
3350 goto done;
3351
3352 for (i = 0; i < SidArray->Count; i++)
3353 {
3354 ConvertSidToStringSid(SidArray->Sids[i].SidPointer, &MemberSidString);
3355TRACE("Open %S\n", MemberSidString);
3356
3357 Status = SampRegOpenKey(MembersKeyHandle,
3358 MemberSidString,
3359 KEY_READ,
3360 &MemberKeyHandle);
3361 TRACE("SampRegOpenKey returned %08lX\n", Status);
3362 if (NT_SUCCESS(Status))
3363 {
3364 Status = SampRegQueryKeyInfo(MemberKeyHandle,
3365 NULL,
3366 &ValueCount);
3367 if (NT_SUCCESS(Status))
3368 {
3369 TRACE("Found %lu values\n", ValueCount);
3370 MaxSidCount += ValueCount;
3371 }
3372
3373 SampRegCloseKey(&MemberKeyHandle);
3374 }
3375
3376 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
3377 Status = STATUS_SUCCESS;
3378
3379 LocalFree(MemberSidString);
3380 }
3381
3382 if (MaxSidCount == 0)
3383 {
3384 Status = STATUS_SUCCESS;
3385 goto done;
3386 }
3387
3388 TRACE("Maximum sid count: %lu\n", MaxSidCount);
3389 RidArray = midl_user_allocate(MaxSidCount * sizeof(ULONG));
3390 if (RidArray == NULL)
3391 {
3392 Status = STATUS_INSUFFICIENT_RESOURCES;
3393 goto done;
3394 }
3395
3396 RidIndex = 0;
3397 for (i = 0; i < SidArray->Count; i++)
3398 {
3399 ConvertSidToStringSid(SidArray->Sids[i].SidPointer, &MemberSidString);
3400TRACE("Open %S\n", MemberSidString);
3401
3402 Status = SampRegOpenKey(MembersKeyHandle,
3403 MemberSidString,
3404 KEY_READ,
3405 &MemberKeyHandle);
3406 TRACE("SampRegOpenKey returned %08lX\n", Status);
3407 if (NT_SUCCESS(Status))
3408 {
3409 Status = SampRegQueryKeyInfo(MemberKeyHandle,
3410 NULL,
3411 &ValueCount);
3412 if (NT_SUCCESS(Status))
3413 {
3414 TRACE("Found %lu values\n", ValueCount);
3415
3416 for (j = 0; j < ValueCount; j++)
3417 {
3418 DataLength = 9 * sizeof(WCHAR);
3419 Status = SampRegEnumerateValue(MemberKeyHandle,
3420 j,
3421 NameBuffer,
3422 &DataLength,
3423 NULL,
3424 NULL,
3425 NULL);
3426 if (NT_SUCCESS(Status))
3427 {
3428 /* FIXME: Do not return each RID more than once. */
3429 RidArray[RidIndex] = wcstoul(NameBuffer, NULL, 16);
3430 RidIndex++;
3431 }
3432 }
3433 }
3434
3435 SampRegCloseKey(&MemberKeyHandle);
3436 }
3437
3438 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
3439 Status = STATUS_SUCCESS;
3440
3441 LocalFree(MemberSidString);
3442 }
3443
3444done:
3445 SampRegCloseKey(&MembersKeyHandle);
3446 SampRegCloseKey(&AliasesKeyHandle);
3447
3448 if (NT_SUCCESS(Status))
3449 {
3450 Membership->Count = MaxSidCount;
3451 Membership->Element = RidArray;
3452 }
3453 else
3454 {
3455 if (RidArray != NULL)
3456 midl_user_free(RidArray);
3457 }
3458
3459 RtlReleaseResource(&SampResource);
3460
3461 return Status;
3462}
3463
3464
3465/* Function 17 */
3466NTSTATUS
3467NTAPI
3468SamrLookupNamesInDomain(IN SAMPR_HANDLE DomainHandle,
3469 IN ULONG Count,
3470 IN RPC_UNICODE_STRING Names[],
3471 OUT PSAMPR_ULONG_ARRAY RelativeIds,
3472 OUT PSAMPR_ULONG_ARRAY Use)
3473{
3474 PSAM_DB_OBJECT DomainObject;
3475 HANDLE AccountsKeyHandle = NULL;
3476 HANDLE NamesKeyHandle = NULL;
3477 ULONG MappedCount = 0;
3478 ULONG DataLength;
3479 ULONG i;
3480 ULONG RelativeId;
3481 NTSTATUS Status;
3482
3483 TRACE("SamrLookupNamesInDomain(%p %lu %p %p %p)\n",
3484 DomainHandle, Count, Names, RelativeIds, Use);
3485
3486 RtlAcquireResourceShared(&SampResource,
3487 TRUE);
3488
3489 /* Validate the domain handle */
3490 Status = SampValidateDbObject(DomainHandle,
3491 SamDbDomainObject,
3492 DOMAIN_LOOKUP,
3493 &DomainObject);
3494 if (!NT_SUCCESS(Status))
3495 {
3496 TRACE("failed with status 0x%08lx\n", Status);
3497 goto done;
3498 }
3499
3500 RelativeIds->Count = 0;
3501 Use->Count = 0;
3502
3503 if (Count == 0)
3504 {
3505 Status = STATUS_SUCCESS;
3506 goto done;
3507 }
3508
3509 /* Allocate the relative IDs array */
3510 RelativeIds->Element = midl_user_allocate(Count * sizeof(ULONG));
3511 if (RelativeIds->Element == NULL)
3512 {
3513 Status = STATUS_INSUFFICIENT_RESOURCES;
3514 goto done;
3515 }
3516
3517 /* Allocate the use array */
3518 Use->Element = midl_user_allocate(Count * sizeof(ULONG));
3519 if (Use->Element == NULL)
3520 {
3521 Status = STATUS_INSUFFICIENT_RESOURCES;
3522 goto done;
3523 }
3524
3525 RelativeIds->Count = Count;
3526 Use->Count = Count;
3527
3528 for (i = 0; i < Count; i++)
3529 {
3530 TRACE("Name: %S\n", Names[i].Buffer);
3531
3532 RelativeId = 0;
3533
3534 /* Lookup aliases */
3535 Status = SampRegOpenKey(DomainObject->KeyHandle,
3536 L"Aliases",
3537 KEY_READ,
3538 &AccountsKeyHandle);
3539 if (NT_SUCCESS(Status))
3540 {
3541 Status = SampRegOpenKey(AccountsKeyHandle,
3542 L"Names",
3543 KEY_READ,
3544 &NamesKeyHandle);
3545 if (NT_SUCCESS(Status))
3546 {
3547 DataLength = sizeof(ULONG);
3548 Status = SampRegQueryValue(NamesKeyHandle,
3549 Names[i].Buffer,
3550 NULL,
3551 &RelativeId,
3552 &DataLength);
3553
3554 SampRegCloseKey(&NamesKeyHandle);
3555 }
3556
3557 SampRegCloseKey(&AccountsKeyHandle);
3558 }
3559
3560 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
3561 break;
3562
3563 /* Return alias account */
3564 if (NT_SUCCESS(Status) && RelativeId != 0)
3565 {
3566 TRACE("Rid: %lu\n", RelativeId);
3567 RelativeIds->Element[i] = RelativeId;
3568 Use->Element[i] = SidTypeAlias;
3569 MappedCount++;
3570 continue;
3571 }
3572
3573 /* Lookup groups */
3574 Status = SampRegOpenKey(DomainObject->KeyHandle,
3575 L"Groups",
3576 KEY_READ,
3577 &AccountsKeyHandle);
3578 if (NT_SUCCESS(Status))
3579 {
3580 Status = SampRegOpenKey(AccountsKeyHandle,
3581 L"Names",
3582 KEY_READ,
3583 &NamesKeyHandle);
3584 if (NT_SUCCESS(Status))
3585 {
3586 DataLength = sizeof(ULONG);
3587 Status = SampRegQueryValue(NamesKeyHandle,
3588 Names[i].Buffer,
3589 NULL,
3590 &RelativeId,
3591 &DataLength);
3592
3593 SampRegCloseKey(&NamesKeyHandle);
3594 }
3595
3596 SampRegCloseKey(&AccountsKeyHandle);
3597 }
3598
3599 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
3600 break;
3601
3602 /* Return group account */
3603 if (NT_SUCCESS(Status) && RelativeId != 0)
3604 {
3605 TRACE("Rid: %lu\n", RelativeId);
3606 RelativeIds->Element[i] = RelativeId;
3607 Use->Element[i] = SidTypeGroup;
3608 MappedCount++;
3609 continue;
3610 }
3611
3612 /* Lookup users */
3613 Status = SampRegOpenKey(DomainObject->KeyHandle,
3614 L"Users",
3615 KEY_READ,
3616 &AccountsKeyHandle);
3617 if (NT_SUCCESS(Status))
3618 {
3619 Status = SampRegOpenKey(AccountsKeyHandle,
3620 L"Names",
3621 KEY_READ,
3622 &NamesKeyHandle);
3623 if (NT_SUCCESS(Status))
3624 {
3625 DataLength = sizeof(ULONG);
3626 Status = SampRegQueryValue(NamesKeyHandle,
3627 Names[i].Buffer,
3628 NULL,
3629 &RelativeId,
3630 &DataLength);
3631
3632 SampRegCloseKey(&NamesKeyHandle);
3633 }
3634
3635 SampRegCloseKey(&AccountsKeyHandle);
3636 }
3637
3638 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
3639 break;
3640
3641 /* Return user account */
3642 if (NT_SUCCESS(Status) && RelativeId != 0)
3643 {
3644 TRACE("Rid: %lu\n", RelativeId);
3645 RelativeIds->Element[i] = RelativeId;
3646 Use->Element[i] = SidTypeUser;
3647 MappedCount++;
3648 continue;
3649 }
3650
3651 /* Return unknown account */
3652 RelativeIds->Element[i] = 0;
3653 Use->Element[i] = SidTypeUnknown;
3654 }
3655
3656done:
3657 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
3658 Status = STATUS_SUCCESS;
3659
3660 if (NT_SUCCESS(Status))
3661 {
3662 if (MappedCount == 0)
3663 Status = STATUS_NONE_MAPPED;
3664 else if (MappedCount < Count)
3665 Status = STATUS_SOME_NOT_MAPPED;
3666 }
3667 else
3668 {
3669 if (RelativeIds->Element != NULL)
3670 {
3671 midl_user_free(RelativeIds->Element);
3672 RelativeIds->Element = NULL;
3673 }
3674
3675 RelativeIds->Count = 0;
3676
3677 if (Use->Element != NULL)
3678 {
3679 midl_user_free(Use->Element);
3680 Use->Element = NULL;
3681 }
3682
3683 Use->Count = 0;
3684 }
3685
3686 RtlReleaseResource(&SampResource);
3687
3688 TRACE("Returned Status %lx\n", Status);
3689
3690 return Status;
3691}
3692
3693
3694/* Function 18 */
3695NTSTATUS
3696NTAPI
3697SamrLookupIdsInDomain(IN SAMPR_HANDLE DomainHandle,
3698 IN ULONG Count,
3699 IN ULONG *RelativeIds,
3700 OUT PSAMPR_RETURNED_USTRING_ARRAY Names,
3701 OUT PSAMPR_ULONG_ARRAY Use)
3702{
3703 PSAM_DB_OBJECT DomainObject;
3704 WCHAR RidString[9];
3705 HANDLE AccountsKeyHandle = NULL;
3706 HANDLE AccountKeyHandle = NULL;
3707 ULONG MappedCount = 0;
3708 ULONG DataLength;
3709 ULONG i;
3710 NTSTATUS Status;
3711
3712 TRACE("SamrLookupIdsInDomain(%p %lu %p %p %p)\n",
3713 DomainHandle, Count, RelativeIds, Names, Use);
3714
3715 RtlAcquireResourceShared(&SampResource,
3716 TRUE);
3717
3718 /* Validate the domain handle */
3719 Status = SampValidateDbObject(DomainHandle,
3720 SamDbDomainObject,
3721 DOMAIN_LOOKUP,
3722 &DomainObject);
3723 if (!NT_SUCCESS(Status))
3724 {
3725 TRACE("failed with status 0x%08lx\n", Status);
3726 goto done;
3727 }
3728
3729 Names->Count = 0;
3730 Use->Count = 0;
3731
3732 if (Count == 0)
3733 {
3734 Status = STATUS_SUCCESS;
3735 goto done;
3736 }
3737
3738 /* Allocate the names array */
3739 Names->Element = midl_user_allocate(Count * sizeof(*Names->Element));
3740 if (Names->Element == NULL)
3741 {
3742 Status = STATUS_INSUFFICIENT_RESOURCES;
3743 goto done;
3744 }
3745
3746 /* Allocate the use array */
3747 Use->Element = midl_user_allocate(Count * sizeof(*Use->Element));
3748 if (Use->Element == NULL)
3749 {
3750 Status = STATUS_INSUFFICIENT_RESOURCES;
3751 goto done;
3752 }
3753
3754 Names->Count = Count;
3755 Use->Count = Count;
3756
3757 for (i = 0; i < Count; i++)
3758 {
3759 TRACE("RID: %lu\n", RelativeIds[i]);
3760
3761 _swprintf(RidString, L"%08lx", RelativeIds[i]);
3762
3763 /* Lookup aliases */
3764 Status = SampRegOpenKey(DomainObject->KeyHandle,
3765 L"Aliases",
3766 KEY_READ,
3767 &AccountsKeyHandle);
3768 if (NT_SUCCESS(Status))
3769 {
3770 Status = SampRegOpenKey(AccountsKeyHandle,
3771 RidString,
3772 KEY_READ,
3773 &AccountKeyHandle);
3774 if (NT_SUCCESS(Status))
3775 {
3776 DataLength = 0;
3777 Status = SampRegQueryValue(AccountKeyHandle,
3778 L"Name",
3779 NULL,
3780 NULL,
3781 &DataLength);
3782 if (NT_SUCCESS(Status))
3783 {
3784 Names->Element[i].Buffer = midl_user_allocate(DataLength);
3785 if (Names->Element[i].Buffer == NULL)
3786 Status = STATUS_INSUFFICIENT_RESOURCES;
3787
3788 if (NT_SUCCESS(Status))
3789 {
3790 Names->Element[i].MaximumLength = (USHORT)DataLength;
3791 Names->Element[i].Length = (USHORT)(DataLength - sizeof(WCHAR));
3792
3793 Status = SampRegQueryValue(AccountKeyHandle,
3794 L"Name",
3795 NULL,
3796 Names->Element[i].Buffer,
3797 &DataLength);
3798 }
3799 }
3800
3801 SampRegCloseKey(&AccountKeyHandle);
3802 }
3803
3804 SampRegCloseKey(&AccountsKeyHandle);
3805 }
3806
3807 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
3808 break;
3809
3810 /* Return alias account */
3811 if (NT_SUCCESS(Status) && Names->Element[i].Buffer != NULL)
3812 {
3813 TRACE("Name: %S\n", Names->Element[i].Buffer);
3814 Use->Element[i] = SidTypeAlias;
3815 MappedCount++;
3816 continue;
3817 }
3818
3819 /* Lookup groups */
3820 Status = SampRegOpenKey(DomainObject->KeyHandle,
3821 L"Groups",
3822 KEY_READ,
3823 &AccountsKeyHandle);
3824 if (NT_SUCCESS(Status))
3825 {
3826 Status = SampRegOpenKey(AccountsKeyHandle,
3827 RidString,
3828 KEY_READ,
3829 &AccountKeyHandle);
3830 if (NT_SUCCESS(Status))
3831 {
3832 DataLength = 0;
3833 Status = SampRegQueryValue(AccountKeyHandle,
3834 L"Name",
3835 NULL,
3836 NULL,
3837 &DataLength);
3838 if (NT_SUCCESS(Status))
3839 {
3840 Names->Element[i].Buffer = midl_user_allocate(DataLength);
3841 if (Names->Element[i].Buffer == NULL)
3842 Status = STATUS_INSUFFICIENT_RESOURCES;
3843
3844 if (NT_SUCCESS(Status))
3845 {
3846 Names->Element[i].MaximumLength = (USHORT)DataLength;
3847 Names->Element[i].Length = (USHORT)(DataLength - sizeof(WCHAR));
3848
3849 Status = SampRegQueryValue(AccountKeyHandle,
3850 L"Name",
3851 NULL,
3852 Names->Element[i].Buffer,
3853 &DataLength);
3854 }
3855 }
3856
3857 SampRegCloseKey(&AccountKeyHandle);
3858 }
3859
3860 SampRegCloseKey(&AccountsKeyHandle);
3861 }
3862
3863 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
3864 break;
3865
3866 /* Return group account */
3867 if (NT_SUCCESS(Status) && Names->Element[i].Buffer != NULL)
3868 {
3869 TRACE("Name: %S\n", Names->Element[i].Buffer);
3870 Use->Element[i] = SidTypeGroup;
3871 MappedCount++;
3872 continue;
3873 }
3874
3875 /* Lookup users */
3876 Status = SampRegOpenKey(DomainObject->KeyHandle,
3877 L"Users",
3878 KEY_READ,
3879 &AccountsKeyHandle);
3880 if (NT_SUCCESS(Status))
3881 {
3882 Status = SampRegOpenKey(AccountsKeyHandle,
3883 RidString,
3884 KEY_READ,
3885 &AccountKeyHandle);
3886 if (NT_SUCCESS(Status))
3887 {
3888 DataLength = 0;
3889 Status = SampRegQueryValue(AccountKeyHandle,
3890 L"Name",
3891 NULL,
3892 NULL,
3893 &DataLength);
3894 if (NT_SUCCESS(Status))
3895 {
3896 TRACE("DataLength: %lu\n", DataLength);
3897
3898 Names->Element[i].Buffer = midl_user_allocate(DataLength);
3899 if (Names->Element[i].Buffer == NULL)
3900 Status = STATUS_INSUFFICIENT_RESOURCES;
3901
3902 if (NT_SUCCESS(Status))
3903 {
3904 Names->Element[i].MaximumLength = (USHORT)DataLength;
3905 Names->Element[i].Length = (USHORT)(DataLength - sizeof(WCHAR));
3906
3907 Status = SampRegQueryValue(AccountKeyHandle,
3908 L"Name",
3909 NULL,
3910 Names->Element[i].Buffer,
3911 &DataLength);
3912 }
3913 }
3914
3915 SampRegCloseKey(&AccountKeyHandle);
3916 }
3917
3918 SampRegCloseKey(&AccountsKeyHandle);
3919 }
3920
3921 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
3922 break;
3923
3924 /* Return user account */
3925 if (NT_SUCCESS(Status) && Names->Element[i].Buffer != NULL)
3926 {
3927 TRACE("Name: %S\n", Names->Element[i].Buffer);
3928 Use->Element[i] = SidTypeUser;
3929 MappedCount++;
3930 continue;
3931 }
3932
3933 /* Return unknown account */
3934 Use->Element[i] = SidTypeUnknown;
3935 }
3936
3937done:
3938 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
3939 Status = STATUS_SUCCESS;
3940
3941 if (NT_SUCCESS(Status))
3942 {
3943 if (MappedCount == 0)
3944 Status = STATUS_NONE_MAPPED;
3945 else if (MappedCount < Count)
3946 Status = STATUS_SOME_NOT_MAPPED;
3947 }
3948 else
3949 {
3950 if (Names->Element != NULL)
3951 {
3952 for (i = 0; i < Count; i++)
3953 {
3954 if (Names->Element[i].Buffer != NULL)
3955 midl_user_free(Names->Element[i].Buffer);
3956 }
3957
3958 midl_user_free(Names->Element);
3959 Names->Element = NULL;
3960 }
3961
3962 Names->Count = 0;
3963
3964 if (Use->Element != NULL)
3965 {
3966 midl_user_free(Use->Element);
3967 Use->Element = NULL;
3968 }
3969
3970 Use->Count = 0;
3971 }
3972
3973 RtlReleaseResource(&SampResource);
3974
3975 return Status;
3976}
3977
3978
3979/* Function 19 */
3980NTSTATUS
3981NTAPI
3982SamrOpenGroup(IN SAMPR_HANDLE DomainHandle,
3983 IN ACCESS_MASK DesiredAccess,
3984 IN unsigned long GroupId,
3985 OUT SAMPR_HANDLE *GroupHandle)
3986{
3987 PSAM_DB_OBJECT DomainObject;
3988 PSAM_DB_OBJECT GroupObject;
3989 WCHAR szRid[9];
3990 NTSTATUS Status;
3991
3992 TRACE("SamrOpenGroup(%p %lx %lx %p)\n",
3993 DomainHandle, DesiredAccess, GroupId, GroupHandle);
3994
3995 /* Map generic access rights */
3996 RtlMapGenericMask(&DesiredAccess,
3997 &GroupMapping);
3998
3999 RtlAcquireResourceShared(&SampResource,
4000 TRUE);
4001
4002 /* Validate the domain handle */
4003 Status = SampValidateDbObject(DomainHandle,
4004 SamDbDomainObject,
4005 DOMAIN_LOOKUP,
4006 &DomainObject);
4007 if (!NT_SUCCESS(Status))
4008 {
4009 TRACE("failed with status 0x%08lx\n", Status);
4010 goto done;
4011 }
4012
4013 /* Convert the RID into a string (hex) */
4014 _swprintf(szRid, L"%08lX", GroupId);
4015
4016 /* Create the group object */
4017 Status = SampOpenDbObject(DomainObject,
4018 L"Groups",
4019 szRid,
4020 GroupId,
4021 SamDbGroupObject,
4022 DesiredAccess,
4023 &GroupObject);
4024 if (!NT_SUCCESS(Status))
4025 {
4026 TRACE("failed with status 0x%08lx\n", Status);
4027 goto done;
4028 }
4029
4030 *GroupHandle = (SAMPR_HANDLE)GroupObject;
4031
4032done:
4033 RtlReleaseResource(&SampResource);
4034
4035 return Status;
4036}
4037
4038
4039static NTSTATUS
4040SampQueryGroupGeneral(PSAM_DB_OBJECT GroupObject,
4041 PSAMPR_GROUP_INFO_BUFFER *Buffer)
4042{
4043 PSAMPR_GROUP_INFO_BUFFER InfoBuffer = NULL;
4044 SAM_GROUP_FIXED_DATA FixedData;
4045 ULONG MembersLength = 0;
4046 ULONG Length = 0;
4047 NTSTATUS Status;
4048
4049 *Buffer = NULL;
4050
4051 InfoBuffer = midl_user_allocate(sizeof(SAMPR_GROUP_INFO_BUFFER));
4052 if (InfoBuffer == NULL)
4053 return STATUS_INSUFFICIENT_RESOURCES;
4054
4055 Status = SampGetObjectAttributeString(GroupObject,
4056 L"Name",
4057 &InfoBuffer->General.Name);
4058 if (!NT_SUCCESS(Status))
4059 {
4060 TRACE("Status 0x%08lx\n", Status);
4061 goto done;
4062 }
4063
4064 Status = SampGetObjectAttributeString(GroupObject,
4065 L"AdminComment",
4066 &InfoBuffer->General.AdminComment);
4067 if (!NT_SUCCESS(Status))
4068 {
4069 TRACE("Status 0x%08lx\n", Status);
4070 goto done;
4071 }
4072
4073 Length = sizeof(SAM_GROUP_FIXED_DATA);
4074 Status = SampGetObjectAttribute(GroupObject,
4075 L"F",
4076 NULL,
4077 (PVOID)&FixedData,
4078 &Length);
4079 if (!NT_SUCCESS(Status))
4080 {
4081 TRACE("Status 0x%08lx\n", Status);
4082 goto done;
4083 }
4084
4085 InfoBuffer->General.Attributes = FixedData.Attributes;
4086
4087 Status = SampGetObjectAttribute(GroupObject,
4088 L"Members",
4089 NULL,
4090 NULL,
4091 &MembersLength);
4092 if (!NT_SUCCESS(Status) && Status != STATUS_OBJECT_NAME_NOT_FOUND)
4093 {
4094 TRACE("Status 0x%08lx\n", Status);
4095 goto done;
4096 }
4097
4098 if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
4099 {
4100 InfoBuffer->General.MemberCount = 0;
4101 Status = STATUS_SUCCESS;
4102 }
4103 else
4104 {
4105 InfoBuffer->General.MemberCount = MembersLength / sizeof(ULONG);
4106 }
4107
4108 *Buffer = InfoBuffer;
4109
4110done:
4111 if (!NT_SUCCESS(Status))
4112 {
4113 if (InfoBuffer != NULL)
4114 {
4115 if (InfoBuffer->General.Name.Buffer != NULL)
4116 midl_user_free(InfoBuffer->General.Name.Buffer);
4117
4118 if (InfoBuffer->General.AdminComment.Buffer != NULL)
4119 midl_user_free(InfoBuffer->General.AdminComment.Buffer);
4120
4121 midl_user_free(InfoBuffer);
4122 }
4123 }
4124
4125 return Status;
4126}
4127
4128
4129static NTSTATUS
4130SampQueryGroupName(PSAM_DB_OBJECT GroupObject,
4131 PSAMPR_GROUP_INFO_BUFFER *Buffer)
4132{
4133 PSAMPR_GROUP_INFO_BUFFER InfoBuffer = NULL;
4134 NTSTATUS Status;
4135
4136 *Buffer = NULL;
4137
4138 InfoBuffer = midl_user_allocate(sizeof(SAMPR_GROUP_INFO_BUFFER));
4139 if (InfoBuffer == NULL)
4140 return STATUS_INSUFFICIENT_RESOURCES;
4141
4142 Status = SampGetObjectAttributeString(GroupObject,
4143 L"Name",
4144 &InfoBuffer->Name.Name);
4145 if (!NT_SUCCESS(Status))
4146 {
4147 TRACE("Status 0x%08lx\n", Status);
4148 goto done;
4149 }
4150
4151 *Buffer = InfoBuffer;
4152
4153done:
4154 if (!NT_SUCCESS(Status))
4155 {
4156 if (InfoBuffer != NULL)
4157 {
4158 if (InfoBuffer->Name.Name.Buffer != NULL)
4159 midl_user_free(InfoBuffer->Name.Name.Buffer);
4160
4161 midl_user_free(InfoBuffer);
4162 }
4163 }
4164
4165 return Status;
4166}
4167
4168
4169static NTSTATUS
4170SampQueryGroupAttribute(PSAM_DB_OBJECT GroupObject,
4171 PSAMPR_GROUP_INFO_BUFFER *Buffer)
4172{
4173 PSAMPR_GROUP_INFO_BUFFER InfoBuffer = NULL;
4174 SAM_GROUP_FIXED_DATA FixedData;
4175 ULONG Length = 0;
4176 NTSTATUS Status;
4177
4178 *Buffer = NULL;
4179
4180 InfoBuffer = midl_user_allocate(sizeof(SAMPR_GROUP_INFO_BUFFER));
4181 if (InfoBuffer == NULL)
4182 return STATUS_INSUFFICIENT_RESOURCES;
4183
4184 Length = sizeof(SAM_GROUP_FIXED_DATA);
4185 Status = SampGetObjectAttribute(GroupObject,
4186 L"F",
4187 NULL,
4188 (PVOID)&FixedData,
4189 &Length);
4190 if (!NT_SUCCESS(Status))
4191 {
4192 TRACE("Status 0x%08lx\n", Status);
4193 goto done;
4194 }
4195
4196 InfoBuffer->Attribute.Attributes = FixedData.Attributes;
4197
4198 *Buffer = InfoBuffer;
4199
4200done:
4201 if (!NT_SUCCESS(Status))
4202 {
4203 if (InfoBuffer != NULL)
4204 {
4205 midl_user_free(InfoBuffer);
4206 }
4207 }
4208
4209 return Status;
4210}
4211
4212
4213static NTSTATUS
4214SampQueryGroupAdminComment(PSAM_DB_OBJECT GroupObject,
4215 PSAMPR_GROUP_INFO_BUFFER *Buffer)
4216{
4217 PSAMPR_GROUP_INFO_BUFFER InfoBuffer = NULL;
4218 NTSTATUS Status;
4219
4220 *Buffer = NULL;
4221
4222 InfoBuffer = midl_user_allocate(sizeof(SAMPR_GROUP_INFO_BUFFER));
4223 if (InfoBuffer == NULL)
4224 return STATUS_INSUFFICIENT_RESOURCES;
4225
4226 Status = SampGetObjectAttributeString(GroupObject,
4227 L"AdminComment",
4228 &InfoBuffer->AdminComment.AdminComment);
4229 if (!NT_SUCCESS(Status))
4230 {
4231 TRACE("Status 0x%08lx\n", Status);
4232 goto done;
4233 }
4234
4235 *Buffer = InfoBuffer;
4236
4237done:
4238 if (!NT_SUCCESS(Status))
4239 {
4240 if (InfoBuffer != NULL)
4241 {
4242 if (InfoBuffer->AdminComment.AdminComment.Buffer != NULL)
4243 midl_user_free(InfoBuffer->AdminComment.AdminComment.Buffer);
4244
4245 midl_user_free(InfoBuffer);
4246 }
4247 }
4248
4249 return Status;
4250}
4251
4252
4253/* Function 20 */
4254NTSTATUS
4255NTAPI
4256SamrQueryInformationGroup(IN SAMPR_HANDLE GroupHandle,
4257 IN GROUP_INFORMATION_CLASS GroupInformationClass,
4258 OUT PSAMPR_GROUP_INFO_BUFFER *Buffer)
4259{
4260 PSAM_DB_OBJECT GroupObject;
4261 NTSTATUS Status;
4262
4263 TRACE("SamrQueryInformationGroup(%p %lu %p)\n",
4264 GroupHandle, GroupInformationClass, Buffer);
4265
4266 RtlAcquireResourceShared(&SampResource,
4267 TRUE);
4268
4269 /* Validate the group handle */
4270 Status = SampValidateDbObject(GroupHandle,
4271 SamDbGroupObject,
4272 GROUP_READ_INFORMATION,
4273 &GroupObject);
4274 if (!NT_SUCCESS(Status))
4275 goto done;
4276
4277 switch (GroupInformationClass)
4278 {
4279 case GroupGeneralInformation:
4280 Status = SampQueryGroupGeneral(GroupObject,
4281 Buffer);
4282 break;
4283
4284 case GroupNameInformation:
4285 Status = SampQueryGroupName(GroupObject,
4286 Buffer);
4287 break;
4288
4289 case GroupAttributeInformation:
4290 Status = SampQueryGroupAttribute(GroupObject,
4291 Buffer);
4292 break;
4293
4294 case GroupAdminCommentInformation:
4295 Status = SampQueryGroupAdminComment(GroupObject,
4296 Buffer);
4297 break;
4298
4299 default:
4300 Status = STATUS_INVALID_INFO_CLASS;
4301 break;
4302 }
4303
4304done:
4305 RtlReleaseResource(&SampResource);
4306
4307 return Status;
4308}
4309
4310
4311static NTSTATUS
4312SampSetGroupName(PSAM_DB_OBJECT GroupObject,
4313 PSAMPR_GROUP_INFO_BUFFER Buffer)
4314{
4315 UNICODE_STRING OldGroupName = {0, 0, NULL};
4316 UNICODE_STRING NewGroupName;
4317 NTSTATUS Status;
4318
4319 Status = SampGetObjectAttributeString(GroupObject,
4320 L"Name",
4321 (PRPC_UNICODE_STRING)&OldGroupName);
4322 if (!NT_SUCCESS(Status))
4323 {
4324 TRACE("SampGetObjectAttributeString failed (Status 0x%08lx)\n", Status);
4325 goto done;
4326 }
4327
4328 /* Check the new account name */
4329 Status = SampCheckAccountName(&Buffer->Name.Name, 256);
4330 if (!NT_SUCCESS(Status))
4331 {
4332 TRACE("SampCheckAccountName failed (Status 0x%08lx)\n", Status);
4333 return Status;
4334 }
4335
4336 NewGroupName.Length = Buffer->Name.Name.Length;
4337 NewGroupName.MaximumLength = Buffer->Name.Name.MaximumLength;
4338 NewGroupName.Buffer = Buffer->Name.Name.Buffer;
4339
4340 if (!RtlEqualUnicodeString(&OldGroupName, &NewGroupName, TRUE))
4341 {
4342 Status = SampCheckAccountNameInDomain(GroupObject->ParentObject,
4343 NewGroupName.Buffer);
4344 if (!NT_SUCCESS(Status))
4345 {
4346 TRACE("Group name \'%S\' already exists in domain (Status 0x%08lx)\n",
4347 NewGroupName.Buffer, Status);
4348 goto done;
4349 }
4350 }
4351
4352 Status = SampSetAccountNameInDomain(GroupObject->ParentObject,
4353 L"Groups",
4354 NewGroupName.Buffer,
4355 GroupObject->RelativeId);
4356 if (!NT_SUCCESS(Status))
4357 {
4358 TRACE("SampSetAccountNameInDomain failed (Status 0x%08lx)\n", Status);
4359 goto done;
4360 }
4361
4362 Status = SampRemoveAccountNameFromDomain(GroupObject->ParentObject,
4363 L"Groups",
4364 OldGroupName.Buffer);
4365 if (!NT_SUCCESS(Status))
4366 {
4367 TRACE("SampRemoveAccountNameFromDomain failed (Status 0x%08lx)\n", Status);
4368 goto done;
4369 }
4370
4371 Status = SampSetObjectAttributeString(GroupObject,
4372 L"Name",
4373 (PRPC_UNICODE_STRING)&NewGroupName);
4374 if (!NT_SUCCESS(Status))
4375 {
4376 TRACE("SampSetObjectAttribute failed (Status 0x%08lx)\n", Status);
4377 }
4378
4379done:
4380 if (OldGroupName.Buffer != NULL)
4381 midl_user_free(OldGroupName.Buffer);
4382
4383 return Status;
4384}
4385
4386
4387static NTSTATUS
4388SampSetGroupAttribute(PSAM_DB_OBJECT GroupObject,
4389 PSAMPR_GROUP_INFO_BUFFER Buffer)
4390{
4391 SAM_GROUP_FIXED_DATA FixedData;
4392 ULONG Length = 0;
4393 NTSTATUS Status;
4394
4395 Length = sizeof(SAM_GROUP_FIXED_DATA);
4396 Status = SampGetObjectAttribute(GroupObject,
4397 L"F",
4398 NULL,
4399 (PVOID)&FixedData,
4400 &Length);
4401 if (!NT_SUCCESS(Status))
4402 goto done;
4403
4404 FixedData.Attributes = Buffer->Attribute.Attributes;
4405
4406 Status = SampSetObjectAttribute(GroupObject,
4407 L"F",
4408 REG_BINARY,
4409 &FixedData,
4410 Length);
4411
4412done:
4413 return Status;
4414}
4415
4416
4417/* Function 21 */
4418NTSTATUS
4419NTAPI
4420SamrSetInformationGroup(IN SAMPR_HANDLE GroupHandle,
4421 IN GROUP_INFORMATION_CLASS GroupInformationClass,
4422 IN PSAMPR_GROUP_INFO_BUFFER Buffer)
4423{
4424 PSAM_DB_OBJECT GroupObject;
4425 NTSTATUS Status;
4426
4427 TRACE("SamrSetInformationGroup(%p %lu %p)\n",
4428 GroupHandle, GroupInformationClass, Buffer);
4429
4430 RtlAcquireResourceExclusive(&SampResource,
4431 TRUE);
4432
4433 /* Validate the group handle */
4434 Status = SampValidateDbObject(GroupHandle,
4435 SamDbGroupObject,
4436 GROUP_WRITE_ACCOUNT,
4437 &GroupObject);
4438 if (!NT_SUCCESS(Status))
4439 goto done;
4440
4441 switch (GroupInformationClass)
4442 {
4443 case GroupNameInformation:
4444 Status = SampSetGroupName(GroupObject,
4445 Buffer);
4446 break;
4447
4448 case GroupAttributeInformation:
4449 Status = SampSetGroupAttribute(GroupObject,
4450 Buffer);
4451 break;
4452
4453 case GroupAdminCommentInformation:
4454 Status = SampSetObjectAttributeString(GroupObject,
4455 L"AdminComment",
4456 &Buffer->AdminComment.AdminComment);
4457 break;
4458
4459 default:
4460 Status = STATUS_INVALID_INFO_CLASS;
4461 break;
4462 }
4463
4464done:
4465 RtlReleaseResource(&SampResource);
4466
4467 return Status;
4468}
4469
4470
4471/* Function 22 */
4472NTSTATUS
4473NTAPI
4474SamrAddMemberToGroup(IN SAMPR_HANDLE GroupHandle,
4475 IN unsigned long MemberId,
4476 IN unsigned long Attributes)
4477{
4478 PSAM_DB_OBJECT GroupObject;
4479 PSAM_DB_OBJECT UserObject = NULL;
4480 NTSTATUS Status;
4481
4482 TRACE("SamrAddMemberToGroup(%p %lu %lx)\n",
4483 GroupHandle, MemberId, Attributes);
4484
4485 RtlAcquireResourceExclusive(&SampResource,
4486 TRUE);
4487
4488 /* Validate the group handle */
4489 Status = SampValidateDbObject(GroupHandle,
4490 SamDbGroupObject,
4491 GROUP_ADD_MEMBER,
4492 &GroupObject);
4493 if (!NT_SUCCESS(Status))
4494 goto done;
4495
4496 /* Open the user object in the same domain */
4497 Status = SampOpenUserObject(GroupObject->ParentObject,
4498 MemberId,
4499 0,
4500 &UserObject);
4501 if (!NT_SUCCESS(Status))
4502 {
4503 TRACE("SampOpenUserObject() failed (Status 0x%08lx)\n", Status);
4504 goto done;
4505 }
4506
4507 /* Add group membership to the user object */
4508 Status = SampAddGroupMembershipToUser(UserObject,
4509 GroupObject->RelativeId,
4510 Attributes);
4511 if (!NT_SUCCESS(Status))
4512 {
4513 TRACE("SampAddGroupMembershipToUser() failed (Status 0x%08lx)\n", Status);
4514 goto done;
4515 }
4516
4517 /* Add the member to the group object */
4518 Status = SampAddMemberToGroup(GroupObject,
4519 MemberId);
4520 if (!NT_SUCCESS(Status))
4521 {
4522 TRACE("SampAddMemberToGroup() failed (Status 0x%08lx)\n", Status);
4523 }
4524
4525done:
4526 if (UserObject)
4527 SampCloseDbObject(UserObject);
4528
4529 RtlReleaseResource(&SampResource);
4530
4531 return Status;
4532}
4533
4534
4535/* Function 23 */
4536NTSTATUS
4537NTAPI
4538SamrDeleteGroup(IN OUT SAMPR_HANDLE *GroupHandle)
4539{
4540 PSAM_DB_OBJECT GroupObject;
4541 ULONG Length = 0;
4542 NTSTATUS Status;
4543
4544 TRACE("SamrDeleteGroup(%p)\n", GroupHandle);
4545
4546 RtlAcquireResourceExclusive(&SampResource,
4547 TRUE);
4548
4549 /* Validate the group handle */
4550 Status = SampValidateDbObject(*GroupHandle,
4551 SamDbGroupObject,
4552 DELETE,
4553 &GroupObject);
4554 if (!NT_SUCCESS(Status))
4555 {
4556 TRACE("SampValidateDbObject() failed (Status 0x%08lx)\n", Status);
4557 goto done;
4558 }
4559
4560 /* Fail, if the group is built-in */
4561 if (GroupObject->RelativeId < 1000)
4562 {
4563 TRACE("You can not delete a special account!\n");
4564 Status = STATUS_SPECIAL_ACCOUNT;
4565 goto done;
4566 }
4567
4568 /* Get the length of the Members attribute */
4569 SampGetObjectAttribute(GroupObject,
4570 L"Members",
4571 NULL,
4572 NULL,
4573 &Length);
4574
4575 /* Fail, if the group has members */
4576 if (Length != 0)
4577 {
4578 TRACE("There are still members in the group!\n");
4579 Status = STATUS_MEMBER_IN_GROUP;
4580 goto done;
4581 }
4582
4583 /* FIXME: Remove the group from all aliases */
4584
4585 /* Delete the group from the database */
4586 Status = SampDeleteAccountDbObject(GroupObject);
4587 if (!NT_SUCCESS(Status))
4588 {
4589 TRACE("SampDeleteAccountDbObject() failed (Status 0x%08lx)\n", Status);
4590 goto done;
4591 }
4592
4593 /* Invalidate the handle */
4594 *GroupHandle = NULL;
4595
4596done:
4597 RtlReleaseResource(&SampResource);
4598
4599 return Status;
4600}
4601
4602
4603/* Function 24 */
4604NTSTATUS
4605NTAPI
4606SamrRemoveMemberFromGroup(IN SAMPR_HANDLE GroupHandle,
4607 IN unsigned long MemberId)
4608{
4609 PSAM_DB_OBJECT GroupObject;
4610 PSAM_DB_OBJECT UserObject = NULL;
4611 NTSTATUS Status;
4612
4613 TRACE("SamrRemoveMemberFromGroup(%p %lu)\n",
4614 GroupHandle, MemberId);
4615
4616 RtlAcquireResourceExclusive(&SampResource,
4617 TRUE);
4618
4619 /* Validate the group handle */
4620 Status = SampValidateDbObject(GroupHandle,
4621 SamDbGroupObject,
4622 GROUP_REMOVE_MEMBER,
4623 &GroupObject);
4624 if (!NT_SUCCESS(Status))
4625 goto done;
4626
4627 /* Open the user object in the same domain */
4628 Status = SampOpenUserObject(GroupObject->ParentObject,
4629 MemberId,
4630 0,
4631 &UserObject);
4632 if (!NT_SUCCESS(Status))
4633 {
4634 ERR("SampOpenUserObject() failed (Status 0x%08lx)\n", Status);
4635 goto done;
4636 }
4637
4638 /* Remove group membership from the user object */
4639 Status = SampRemoveGroupMembershipFromUser(UserObject,
4640 GroupObject->RelativeId);
4641 if (!NT_SUCCESS(Status))
4642 {
4643 ERR("SampAddGroupMembershipToUser() failed (Status 0x%08lx)\n", Status);
4644 goto done;
4645 }
4646
4647 /* Remove the member from the group object */
4648 Status = SampRemoveMemberFromGroup(GroupObject,
4649 MemberId);
4650 if (!NT_SUCCESS(Status))
4651 {
4652 ERR("SampRemoveMemberFromGroup() failed (Status 0x%08lx)\n", Status);
4653 }
4654
4655done:
4656 if (UserObject)
4657 SampCloseDbObject(UserObject);
4658
4659 RtlReleaseResource(&SampResource);
4660
4661 return Status;
4662}
4663
4664
4665/* Function 25 */
4666NTSTATUS
4667NTAPI
4668SamrGetMembersInGroup(IN SAMPR_HANDLE GroupHandle,
4669 OUT PSAMPR_GET_MEMBERS_BUFFER *Members)
4670{
4671 PSAMPR_GET_MEMBERS_BUFFER MembersBuffer = NULL;
4672 PSAM_DB_OBJECT GroupObject;
4673 ULONG Length = 0;
4674 ULONG i;
4675 NTSTATUS Status;
4676
4677 TRACE("SamrGetMembersInGroup(%p %p)\n",
4678 GroupHandle, Members);
4679
4680 RtlAcquireResourceShared(&SampResource,
4681 TRUE);
4682
4683 /* Validate the group handle */
4684 Status = SampValidateDbObject(GroupHandle,
4685 SamDbGroupObject,
4686 GROUP_LIST_MEMBERS,
4687 &GroupObject);
4688 if (!NT_SUCCESS(Status))
4689 goto done;
4690
4691 MembersBuffer = midl_user_allocate(sizeof(SAMPR_GET_MEMBERS_BUFFER));
4692 if (MembersBuffer == NULL)
4693 {
4694 Status = STATUS_INSUFFICIENT_RESOURCES;
4695 goto done;
4696 }
4697
4698 SampGetObjectAttribute(GroupObject,
4699 L"Members",
4700 NULL,
4701 NULL,
4702 &Length);
4703
4704 if (Length == 0)
4705 {
4706 MembersBuffer->MemberCount = 0;
4707 MembersBuffer->Members = NULL;
4708 MembersBuffer->Attributes = NULL;
4709
4710 *Members = MembersBuffer;
4711
4712 Status = STATUS_SUCCESS;
4713 goto done;
4714 }
4715
4716 MembersBuffer->Members = midl_user_allocate(Length);
4717 if (MembersBuffer->Members == NULL)
4718 {
4719 Status = STATUS_INSUFFICIENT_RESOURCES;
4720 goto done;
4721 }
4722
4723 MembersBuffer->Attributes = midl_user_allocate(Length);
4724 if (MembersBuffer->Attributes == NULL)
4725 {
4726 Status = STATUS_INSUFFICIENT_RESOURCES;
4727 goto done;
4728 }
4729
4730 Status = SampGetObjectAttribute(GroupObject,
4731 L"Members",
4732 NULL,
4733 MembersBuffer->Members,
4734 &Length);
4735 if (!NT_SUCCESS(Status))
4736 {
4737 TRACE("SampGetObjectAttributes() failed (Status 0x%08lx)\n", Status);
4738 goto done;
4739 }
4740
4741 MembersBuffer->MemberCount = Length / sizeof(ULONG);
4742
4743 for (i = 0; i < MembersBuffer->MemberCount; i++)
4744 {
4745 Status = SampGetUserGroupAttributes(GroupObject->ParentObject,
4746 MembersBuffer->Members[i],
4747 GroupObject->RelativeId,
4748 &(MembersBuffer->Attributes[i]));
4749 if (!NT_SUCCESS(Status))
4750 {
4751 TRACE("SampGetUserGroupAttributes() failed (Status 0x%08lx)\n", Status);
4752 goto done;
4753 }
4754 }
4755
4756 *Members = MembersBuffer;
4757
4758done:
4759 if (!NT_SUCCESS(Status))
4760 {
4761 if (MembersBuffer != NULL)
4762 {
4763 if (MembersBuffer->Members != NULL)
4764 midl_user_free(MembersBuffer->Members);
4765
4766 if (MembersBuffer->Attributes != NULL)
4767 midl_user_free(MembersBuffer->Attributes);
4768
4769 midl_user_free(MembersBuffer);
4770 }
4771 }
4772
4773 RtlReleaseResource(&SampResource);
4774
4775 return Status;
4776}
4777
4778
4779/* Function 26 */
4780NTSTATUS
4781NTAPI
4782SamrSetMemberAttributesOfGroup(IN SAMPR_HANDLE GroupHandle,
4783 IN unsigned long MemberId,
4784 IN unsigned long Attributes)
4785{
4786 PSAM_DB_OBJECT GroupObject;
4787 NTSTATUS Status;
4788
4789 TRACE("SamrSetMemberAttributesOfGroup(%p %lu %lx)\n",
4790 GroupHandle, MemberId, Attributes);
4791
4792 RtlAcquireResourceExclusive(&SampResource,
4793 TRUE);
4794
4795 /* Validate the group handle */
4796 Status = SampValidateDbObject(GroupHandle,
4797 SamDbGroupObject,
4798 GROUP_ADD_MEMBER,
4799 &GroupObject);
4800 if (!NT_SUCCESS(Status))
4801 {
4802 TRACE("SampValidateDbObject failed with status 0x%08lx\n", Status);
4803 goto done;
4804 }
4805
4806 Status = SampSetUserGroupAttributes(GroupObject->ParentObject,
4807 MemberId,
4808 GroupObject->RelativeId,
4809 Attributes);
4810 if (!NT_SUCCESS(Status))
4811 {
4812 TRACE("SampSetUserGroupAttributes failed with status 0x%08lx\n", Status);
4813 }
4814
4815done:
4816 RtlReleaseResource(&SampResource);
4817
4818 return Status;
4819}
4820
4821
4822/* Function 27 */
4823NTSTATUS
4824NTAPI
4825SamrOpenAlias(IN SAMPR_HANDLE DomainHandle,
4826 IN ACCESS_MASK DesiredAccess,
4827 IN ULONG AliasId,
4828 OUT SAMPR_HANDLE *AliasHandle)
4829{
4830 PSAM_DB_OBJECT DomainObject;
4831 PSAM_DB_OBJECT AliasObject;
4832 WCHAR szRid[9];
4833 NTSTATUS Status;
4834
4835 TRACE("SamrOpenAlias(%p %lx %lx %p)\n",
4836 DomainHandle, DesiredAccess, AliasId, AliasHandle);
4837
4838 /* Map generic access rights */
4839 RtlMapGenericMask(&DesiredAccess,
4840 &AliasMapping);
4841
4842 RtlAcquireResourceShared(&SampResource,
4843 TRUE);
4844
4845 /* Validate the domain handle */
4846 Status = SampValidateDbObject(DomainHandle,
4847 SamDbDomainObject,
4848 DOMAIN_LOOKUP,
4849 &DomainObject);
4850 if (!NT_SUCCESS(Status))
4851 {
4852 TRACE("failed with status 0x%08lx\n", Status);
4853 goto done;
4854 }
4855
4856 /* Convert the RID into a string (hex) */
4857 _swprintf(szRid, L"%08lX", AliasId);
4858
4859 /* Create the alias object */
4860 Status = SampOpenDbObject(DomainObject,
4861 L"Aliases",
4862 szRid,
4863 AliasId,
4864 SamDbAliasObject,
4865 DesiredAccess,
4866 &AliasObject);
4867 if (!NT_SUCCESS(Status))
4868 {
4869 TRACE("failed with status 0x%08lx\n", Status);
4870 goto done;
4871 }
4872
4873 *AliasHandle = (SAMPR_HANDLE)AliasObject;
4874
4875done:
4876 RtlReleaseResource(&SampResource);
4877
4878 return Status;
4879}
4880
4881
4882static NTSTATUS
4883SampQueryAliasGeneral(PSAM_DB_OBJECT AliasObject,
4884 PSAMPR_ALIAS_INFO_BUFFER *Buffer)
4885{
4886 PSAMPR_ALIAS_INFO_BUFFER InfoBuffer = NULL;
4887 HANDLE MembersKeyHandle = NULL;
4888 NTSTATUS Status;
4889
4890 *Buffer = NULL;
4891
4892 InfoBuffer = midl_user_allocate(sizeof(SAMPR_ALIAS_INFO_BUFFER));
4893 if (InfoBuffer == NULL)
4894 return STATUS_INSUFFICIENT_RESOURCES;
4895
4896 Status = SampGetObjectAttributeString(AliasObject,
4897 L"Name",
4898 &InfoBuffer->General.Name);
4899 if (!NT_SUCCESS(Status))
4900 {
4901 TRACE("Status 0x%08lx\n", Status);
4902 goto done;
4903 }
4904
4905 Status = SampGetObjectAttributeString(AliasObject,
4906 L"Description",
4907 &InfoBuffer->General.AdminComment);
4908 if (!NT_SUCCESS(Status))
4909 {
4910 TRACE("Status 0x%08lx\n", Status);
4911 goto done;
4912 }
4913
4914 /* Open the Members subkey */
4915 Status = SampRegOpenKey(AliasObject->KeyHandle,
4916 L"Members",
4917 KEY_READ,
4918 &MembersKeyHandle);
4919 if (NT_SUCCESS(Status))
4920 {
4921 /* Retrieve the number of members of the alias */
4922 Status = SampRegQueryKeyInfo(MembersKeyHandle,
4923 NULL,
4924 &InfoBuffer->General.MemberCount);
4925 if (!NT_SUCCESS(Status))
4926 {
4927 TRACE("Status 0x%08lx\n", Status);
4928 goto done;
4929 }
4930 }
4931 else if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
4932 {
4933 InfoBuffer->General.MemberCount = 0;
4934 Status = STATUS_SUCCESS;
4935 }
4936 else
4937 {
4938 TRACE("Status 0x%08lx\n", Status);
4939 goto done;
4940 }
4941
4942 *Buffer = InfoBuffer;
4943
4944done:
4945 SampRegCloseKey(&MembersKeyHandle);
4946
4947 if (!NT_SUCCESS(Status))
4948 {
4949 if (InfoBuffer != NULL)
4950 {
4951 if (InfoBuffer->General.Name.Buffer != NULL)
4952 midl_user_free(InfoBuffer->General.Name.Buffer);
4953
4954 if (InfoBuffer->General.AdminComment.Buffer != NULL)
4955 midl_user_free(InfoBuffer->General.AdminComment.Buffer);
4956
4957 midl_user_free(InfoBuffer);
4958 }
4959 }
4960
4961 return Status;
4962}
4963
4964
4965static NTSTATUS
4966SampQueryAliasName(PSAM_DB_OBJECT AliasObject,
4967 PSAMPR_ALIAS_INFO_BUFFER *Buffer)
4968{
4969 PSAMPR_ALIAS_INFO_BUFFER InfoBuffer = NULL;
4970 NTSTATUS Status;
4971
4972 *Buffer = NULL;
4973
4974 InfoBuffer = midl_user_allocate(sizeof(SAMPR_ALIAS_INFO_BUFFER));
4975 if (InfoBuffer == NULL)
4976 return STATUS_INSUFFICIENT_RESOURCES;
4977
4978 Status = SampGetObjectAttributeString(AliasObject,
4979 L"Name",
4980 &InfoBuffer->Name.Name);
4981 if (!NT_SUCCESS(Status))
4982 {
4983 TRACE("Status 0x%08lx\n", Status);
4984 goto done;
4985 }
4986
4987 *Buffer = InfoBuffer;
4988
4989done:
4990 if (!NT_SUCCESS(Status))
4991 {
4992 if (InfoBuffer != NULL)
4993 {
4994 if (InfoBuffer->Name.Name.Buffer != NULL)
4995 midl_user_free(InfoBuffer->Name.Name.Buffer);
4996
4997 midl_user_free(InfoBuffer);
4998 }
4999 }
5000
5001 return Status;
5002}
5003
5004
5005static NTSTATUS
5006SampQueryAliasAdminComment(PSAM_DB_OBJECT AliasObject,
5007 PSAMPR_ALIAS_INFO_BUFFER *Buffer)
5008{
5009 PSAMPR_ALIAS_INFO_BUFFER InfoBuffer = NULL;
5010 NTSTATUS Status;
5011
5012 *Buffer = NULL;
5013
5014 InfoBuffer = midl_user_allocate(sizeof(SAMPR_ALIAS_INFO_BUFFER));
5015 if (InfoBuffer == NULL)
5016 return STATUS_INSUFFICIENT_RESOURCES;
5017
5018 Status = SampGetObjectAttributeString(AliasObject,
5019 L"Description",
5020 &InfoBuffer->AdminComment.AdminComment);
5021 if (!NT_SUCCESS(Status))
5022 {
5023 TRACE("Status 0x%08lx\n", Status);
5024 goto done;
5025 }
5026
5027 *Buffer = InfoBuffer;
5028
5029done:
5030 if (!NT_SUCCESS(Status))
5031 {
5032 if (InfoBuffer != NULL)
5033 {
5034 if (InfoBuffer->AdminComment.AdminComment.Buffer != NULL)
5035 midl_user_free(InfoBuffer->AdminComment.AdminComment.Buffer);
5036
5037 midl_user_free(InfoBuffer);
5038 }
5039 }
5040
5041 return Status;
5042}
5043
5044
5045/* Function 28 */
5046NTSTATUS
5047NTAPI
5048SamrQueryInformationAlias(IN SAMPR_HANDLE AliasHandle,
5049 IN ALIAS_INFORMATION_CLASS AliasInformationClass,
5050 OUT PSAMPR_ALIAS_INFO_BUFFER *Buffer)
5051{
5052 PSAM_DB_OBJECT AliasObject;
5053 NTSTATUS Status;
5054
5055 TRACE("SamrQueryInformationAlias(%p %lu %p)\n",
5056 AliasHandle, AliasInformationClass, Buffer);
5057
5058 RtlAcquireResourceShared(&SampResource,
5059 TRUE);
5060
5061 /* Validate the alias handle */
5062 Status = SampValidateDbObject(AliasHandle,
5063 SamDbAliasObject,
5064 ALIAS_READ_INFORMATION,
5065 &AliasObject);
5066 if (!NT_SUCCESS(Status))
5067 goto done;
5068
5069 switch (AliasInformationClass)
5070 {
5071 case AliasGeneralInformation:
5072 Status = SampQueryAliasGeneral(AliasObject,
5073 Buffer);
5074 break;
5075
5076 case AliasNameInformation:
5077 Status = SampQueryAliasName(AliasObject,
5078 Buffer);
5079 break;
5080
5081 case AliasAdminCommentInformation:
5082 Status = SampQueryAliasAdminComment(AliasObject,
5083 Buffer);
5084 break;
5085
5086 default:
5087 Status = STATUS_INVALID_INFO_CLASS;
5088 break;
5089 }
5090
5091done:
5092 RtlReleaseResource(&SampResource);
5093
5094 return Status;
5095}
5096
5097
5098static NTSTATUS
5099SampSetAliasName(PSAM_DB_OBJECT AliasObject,
5100 PSAMPR_ALIAS_INFO_BUFFER Buffer)
5101{
5102 UNICODE_STRING OldAliasName = {0, 0, NULL};
5103 UNICODE_STRING NewAliasName;
5104 NTSTATUS Status;
5105
5106 Status = SampGetObjectAttributeString(AliasObject,
5107 L"Name",
5108 (PRPC_UNICODE_STRING)&OldAliasName);
5109 if (!NT_SUCCESS(Status))
5110 {
5111 TRACE("SampGetObjectAttributeString failed (Status 0x%08lx)\n", Status);
5112 goto done;
5113 }
5114
5115 /* Check the new account name */
5116 Status = SampCheckAccountName(&Buffer->Name.Name, 256);
5117 if (!NT_SUCCESS(Status))
5118 {
5119 TRACE("SampCheckAccountName failed (Status 0x%08lx)\n", Status);
5120 return Status;
5121 }
5122
5123 NewAliasName.Length = Buffer->Name.Name.Length;
5124 NewAliasName.MaximumLength = Buffer->Name.Name.MaximumLength;
5125 NewAliasName.Buffer = Buffer->Name.Name.Buffer;
5126
5127 if (!RtlEqualUnicodeString(&OldAliasName, &NewAliasName, TRUE))
5128 {
5129 Status = SampCheckAccountNameInDomain(AliasObject->ParentObject,
5130 NewAliasName.Buffer);
5131 if (!NT_SUCCESS(Status))
5132 {
5133 TRACE("Alias name \'%S\' already exists in domain (Status 0x%08lx)\n",
5134 NewAliasName.Buffer, Status);
5135 goto done;
5136 }
5137 }
5138
5139 Status = SampSetAccountNameInDomain(AliasObject->ParentObject,
5140 L"Aliases",
5141 NewAliasName.Buffer,
5142 AliasObject->RelativeId);
5143 if (!NT_SUCCESS(Status))
5144 {
5145 TRACE("SampSetAccountNameInDomain failed (Status 0x%08lx)\n", Status);
5146 goto done;
5147 }
5148
5149 Status = SampRemoveAccountNameFromDomain(AliasObject->ParentObject,
5150 L"Aliases",
5151 OldAliasName.Buffer);
5152 if (!NT_SUCCESS(Status))
5153 {
5154 TRACE("SampRemoveAccountNameFromDomain failed (Status 0x%08lx)\n", Status);
5155 goto done;
5156 }
5157
5158 Status = SampSetObjectAttributeString(AliasObject,
5159 L"Name",
5160 (PRPC_UNICODE_STRING)&NewAliasName);
5161 if (!NT_SUCCESS(Status))
5162 {
5163 TRACE("SampSetObjectAttribute failed (Status 0x%08lx)\n", Status);
5164 }
5165
5166done:
5167 if (OldAliasName.Buffer != NULL)
5168 midl_user_free(OldAliasName.Buffer);
5169
5170 return Status;
5171}
5172
5173
5174/* Function 29 */
5175NTSTATUS
5176NTAPI
5177SamrSetInformationAlias(IN SAMPR_HANDLE AliasHandle,
5178 IN ALIAS_INFORMATION_CLASS AliasInformationClass,
5179 IN PSAMPR_ALIAS_INFO_BUFFER Buffer)
5180{
5181 PSAM_DB_OBJECT AliasObject;
5182 NTSTATUS Status;
5183
5184 TRACE("SamrSetInformationAlias(%p %lu %p)\n",
5185 AliasHandle, AliasInformationClass, Buffer);
5186
5187 RtlAcquireResourceExclusive(&SampResource,
5188 TRUE);
5189
5190 /* Validate the alias handle */
5191 Status = SampValidateDbObject(AliasHandle,
5192 SamDbAliasObject,
5193 ALIAS_WRITE_ACCOUNT,
5194 &AliasObject);
5195 if (!NT_SUCCESS(Status))
5196 goto done;
5197
5198 switch (AliasInformationClass)
5199 {
5200 case AliasNameInformation:
5201 Status = SampSetAliasName(AliasObject,
5202 Buffer);
5203 break;
5204
5205 case AliasAdminCommentInformation:
5206 Status = SampSetObjectAttributeString(AliasObject,
5207 L"Description",
5208 &Buffer->AdminComment.AdminComment);
5209 break;
5210
5211 default:
5212 Status = STATUS_INVALID_INFO_CLASS;
5213 break;
5214 }
5215
5216done:
5217 RtlReleaseResource(&SampResource);
5218
5219 return Status;
5220}
5221
5222
5223/* Function 30 */
5224NTSTATUS
5225NTAPI
5226SamrDeleteAlias(IN OUT SAMPR_HANDLE *AliasHandle)
5227{
5228 PSAM_DB_OBJECT AliasObject;
5229 NTSTATUS Status;
5230
5231 TRACE("SamrDeleteAlias(%p)\n", AliasHandle);
5232
5233 RtlAcquireResourceExclusive(&SampResource,
5234 TRUE);
5235
5236 /* Validate the alias handle */
5237 Status = SampValidateDbObject(*AliasHandle,
5238 SamDbAliasObject,
5239 DELETE,
5240 &AliasObject);
5241 if (!NT_SUCCESS(Status))
5242 {
5243 TRACE("SampValidateDbObject failed (Status 0x%08lx)\n", Status);
5244 goto done;
5245 }
5246
5247 /* Fail, if the alias is built-in */
5248 if (AliasObject->RelativeId < 1000)
5249 {
5250 TRACE("You can not delete a special account!\n");
5251 Status = STATUS_SPECIAL_ACCOUNT;
5252 goto done;
5253 }
5254
5255 /* Remove all members from the alias */
5256 Status = SampRemoveAllMembersFromAlias(AliasObject);
5257 if (!NT_SUCCESS(Status))
5258 {
5259 TRACE("SampRemoveAllMembersFromAlias() failed (Status 0x%08lx)\n", Status);
5260 goto done;
5261 }
5262
5263 /* Delete the alias from the database */
5264 Status = SampDeleteAccountDbObject(AliasObject);
5265 if (!NT_SUCCESS(Status))
5266 {
5267 TRACE("SampDeleteAccountDbObject() failed (Status 0x%08lx)\n", Status);
5268 goto done;
5269 }
5270
5271 /* Invalidate the handle */
5272 *AliasHandle = NULL;
5273
5274done:
5275 RtlReleaseResource(&SampResource);
5276
5277 return Status;
5278}
5279
5280
5281/* Function 31 */
5282NTSTATUS
5283NTAPI
5284SamrAddMemberToAlias(IN SAMPR_HANDLE AliasHandle,
5285 IN PRPC_SID MemberId)
5286{
5287 PSAM_DB_OBJECT AliasObject;
5288 NTSTATUS Status;
5289
5290 TRACE("SamrAddMemberToAlias(%p %p)\n",
5291 AliasHandle, MemberId);
5292
5293 RtlAcquireResourceExclusive(&SampResource,
5294 TRUE);
5295
5296 /* Validate the alias handle */
5297 Status = SampValidateDbObject(AliasHandle,
5298 SamDbAliasObject,
5299 ALIAS_ADD_MEMBER,
5300 &AliasObject);
5301 if (!NT_SUCCESS(Status))
5302 {
5303 TRACE("failed with status 0x%08lx\n", Status);
5304 goto done;
5305 }
5306
5307 Status = SampAddMemberToAlias(AliasObject,
5308 MemberId);
5309 if (!NT_SUCCESS(Status))
5310 {
5311 TRACE("failed with status 0x%08lx\n", Status);
5312 }
5313
5314done:
5315 RtlReleaseResource(&SampResource);
5316
5317 return Status;
5318}
5319
5320
5321/* Function 32 */
5322NTSTATUS
5323NTAPI
5324SamrRemoveMemberFromAlias(IN SAMPR_HANDLE AliasHandle,
5325 IN PRPC_SID MemberId)
5326{
5327 PSAM_DB_OBJECT AliasObject;
5328 NTSTATUS Status;
5329
5330 TRACE("SamrRemoveMemberFromAlias(%p %p)\n",
5331 AliasHandle, MemberId);
5332
5333 RtlAcquireResourceExclusive(&SampResource,
5334 TRUE);
5335
5336 /* Validate the alias handle */
5337 Status = SampValidateDbObject(AliasHandle,
5338 SamDbAliasObject,
5339 ALIAS_REMOVE_MEMBER,
5340 &AliasObject);
5341 if (!NT_SUCCESS(Status))
5342 {
5343 TRACE("failed with status 0x%08lx\n", Status);
5344 goto done;
5345 }
5346
5347 Status = SampRemoveMemberFromAlias(AliasObject,
5348 MemberId);
5349 if (!NT_SUCCESS(Status))
5350 {
5351 TRACE("failed with status 0x%08lx\n", Status);
5352 }
5353
5354done:
5355 RtlReleaseResource(&SampResource);
5356
5357 return Status;
5358}
5359
5360
5361/* Function 33 */
5362NTSTATUS
5363NTAPI
5364SamrGetMembersInAlias(IN SAMPR_HANDLE AliasHandle,
5365 OUT PSAMPR_PSID_ARRAY_OUT Members)
5366{
5367 PSAM_DB_OBJECT AliasObject;
5368 PSAMPR_SID_INFORMATION MemberArray = NULL;
5369 ULONG MemberCount = 0;
5370 ULONG Index;
5371 NTSTATUS Status;
5372
5373 TRACE("SamrGetMembersInAlias(%p %p %p)\n",
5374 AliasHandle, Members);
5375
5376 RtlAcquireResourceShared(&SampResource,
5377 TRUE);
5378
5379 /* Validate the alias handle */
5380 Status = SampValidateDbObject(AliasHandle,
5381 SamDbAliasObject,
5382 ALIAS_LIST_MEMBERS,
5383 &AliasObject);
5384 if (!NT_SUCCESS(Status))
5385 {
5386 ERR("failed with status 0x%08lx\n", Status);
5387 goto done;
5388 }
5389
5390 Status = SampGetMembersInAlias(AliasObject,
5391 &MemberCount,
5392 &MemberArray);
5393
5394 /* Return the number of members and the member array */
5395 if (NT_SUCCESS(Status))
5396 {
5397 Members->Count = MemberCount;
5398 Members->Sids = MemberArray;
5399 }
5400
5401done:
5402 /* Clean up the members array and the SID buffers if something failed */
5403 if (!NT_SUCCESS(Status))
5404 {
5405 if (MemberArray != NULL)
5406 {
5407 for (Index = 0; Index < MemberCount; Index++)
5408 {
5409 if (MemberArray[Index].SidPointer != NULL)
5410 midl_user_free(MemberArray[Index].SidPointer);
5411 }
5412
5413 midl_user_free(MemberArray);
5414 }
5415 }
5416
5417 RtlReleaseResource(&SampResource);
5418
5419 return Status;
5420}
5421
5422
5423/* Function 34 */
5424NTSTATUS
5425NTAPI
5426SamrOpenUser(IN SAMPR_HANDLE DomainHandle,
5427 IN ACCESS_MASK DesiredAccess,
5428 IN unsigned long UserId,
5429 OUT SAMPR_HANDLE *UserHandle)
5430{
5431 PSAM_DB_OBJECT DomainObject;
5432 PSAM_DB_OBJECT UserObject;
5433 WCHAR szRid[9];
5434 NTSTATUS Status;
5435
5436 TRACE("SamrOpenUser(%p %lx %lx %p)\n",
5437 DomainHandle, DesiredAccess, UserId, UserHandle);
5438
5439 /* Map generic access rights */
5440 RtlMapGenericMask(&DesiredAccess,
5441 &UserMapping);
5442
5443 RtlAcquireResourceShared(&SampResource,
5444 TRUE);
5445
5446 /* Validate the domain handle */
5447 Status = SampValidateDbObject(DomainHandle,
5448 SamDbDomainObject,
5449 DOMAIN_LOOKUP,
5450 &DomainObject);
5451 if (!NT_SUCCESS(Status))
5452 {
5453 TRACE("failed with status 0x%08lx\n", Status);
5454 goto done;
5455 }
5456
5457 /* Convert the RID into a string (hex) */
5458 _swprintf(szRid, L"%08lX", UserId);
5459
5460 /* Create the user object */
5461 Status = SampOpenDbObject(DomainObject,
5462 L"Users",
5463 szRid,
5464 UserId,
5465 SamDbUserObject,
5466 DesiredAccess,
5467 &UserObject);
5468 if (!NT_SUCCESS(Status))
5469 {
5470 TRACE("failed with status 0x%08lx\n", Status);
5471 goto done;
5472 }
5473
5474 *UserHandle = (SAMPR_HANDLE)UserObject;
5475
5476done:
5477 RtlReleaseResource(&SampResource);
5478
5479 return Status;
5480}
5481
5482
5483/* Function 35 */
5484NTSTATUS
5485NTAPI
5486SamrDeleteUser(IN OUT SAMPR_HANDLE *UserHandle)
5487{
5488 PSAM_DB_OBJECT UserObject;
5489 NTSTATUS Status;
5490
5491 TRACE("SamrDeleteUser(%p)\n", UserHandle);
5492
5493 RtlAcquireResourceExclusive(&SampResource,
5494 TRUE);
5495
5496 /* Validate the user handle */
5497 Status = SampValidateDbObject(*UserHandle,
5498 SamDbUserObject,
5499 DELETE,
5500 &UserObject);
5501 if (!NT_SUCCESS(Status))
5502 {
5503 TRACE("SampValidateDbObject() failed (Status 0x%08lx)\n", Status);
5504 goto done;
5505 }
5506
5507 /* Fail, if the user is built-in */
5508 if (UserObject->RelativeId < 1000)
5509 {
5510 TRACE("You can not delete a special account!\n");
5511 Status = STATUS_SPECIAL_ACCOUNT;
5512 goto done;
5513 }
5514
5515 /* Remove the user from all groups */
5516 Status = SampRemoveUserFromAllGroups(UserObject);
5517 if (!NT_SUCCESS(Status))
5518 {
5519 TRACE("SampRemoveUserFromAllGroups() failed (Status 0x%08lx)\n", Status);
5520 goto done;
5521 }
5522
5523 /* Remove the user from all aliases */
5524 Status = SampRemoveUserFromAllAliases(UserObject);
5525 if (!NT_SUCCESS(Status))
5526 {
5527 TRACE("SampRemoveUserFromAllAliases() failed (Status 0x%08lx)\n", Status);
5528 goto done;
5529 }
5530
5531 /* Delete the user from the database */
5532 Status = SampDeleteAccountDbObject(UserObject);
5533 if (!NT_SUCCESS(Status))
5534 {
5535 TRACE("SampDeleteAccountDbObject() failed (Status 0x%08lx)\n", Status);
5536 goto done;
5537 }
5538
5539 /* Invalidate the handle */
5540 *UserHandle = NULL;
5541
5542done:
5543 RtlReleaseResource(&SampResource);
5544
5545 return Status;
5546}
5547
5548
5549static
5550NTSTATUS
5551SampQueryUserGeneral(PSAM_DB_OBJECT UserObject,
5552 PSAMPR_USER_INFO_BUFFER *Buffer)
5553{
5554 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
5555 SAM_USER_FIXED_DATA FixedData;
5556 ULONG Length = 0;
5557 NTSTATUS Status;
5558
5559 *Buffer = NULL;
5560
5561 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
5562 if (InfoBuffer == NULL)
5563 return STATUS_INSUFFICIENT_RESOURCES;
5564
5565 Length = sizeof(SAM_USER_FIXED_DATA);
5566 Status = SampGetObjectAttribute(UserObject,
5567 L"F",
5568 NULL,
5569 (PVOID)&FixedData,
5570 &Length);
5571 if (!NT_SUCCESS(Status))
5572 goto done;
5573
5574 InfoBuffer->General.PrimaryGroupId = FixedData.PrimaryGroupId;
5575
5576 /* Get the Name string */
5577 Status = SampGetObjectAttributeString(UserObject,
5578 L"Name",
5579 &InfoBuffer->General.UserName);
5580 if (!NT_SUCCESS(Status))
5581 {
5582 TRACE("Status 0x%08lx\n", Status);
5583 goto done;
5584 }
5585
5586 /* Get the FullName string */
5587 Status = SampGetObjectAttributeString(UserObject,
5588 L"FullName",
5589 &InfoBuffer->General.FullName);
5590 if (!NT_SUCCESS(Status))
5591 {
5592 TRACE("Status 0x%08lx\n", Status);
5593 goto done;
5594 }
5595
5596 /* Get the AdminComment string */
5597 Status = SampGetObjectAttributeString(UserObject,
5598 L"AdminComment",
5599 &InfoBuffer->General.AdminComment);
5600 if (!NT_SUCCESS(Status))
5601 {
5602 TRACE("Status 0x%08lx\n", Status);
5603 goto done;
5604 }
5605
5606 /* Get the UserComment string */
5607 Status = SampGetObjectAttributeString(UserObject,
5608 L"UserComment",
5609 &InfoBuffer->General.UserComment);
5610 if (!NT_SUCCESS(Status))
5611 {
5612 TRACE("Status 0x%08lx\n", Status);
5613 goto done;
5614 }
5615
5616 *Buffer = InfoBuffer;
5617
5618done:
5619 if (!NT_SUCCESS(Status))
5620 {
5621 if (InfoBuffer != NULL)
5622 {
5623 if (InfoBuffer->General.UserName.Buffer != NULL)
5624 midl_user_free(InfoBuffer->General.UserName.Buffer);
5625
5626 if (InfoBuffer->General.FullName.Buffer != NULL)
5627 midl_user_free(InfoBuffer->General.FullName.Buffer);
5628
5629 if (InfoBuffer->General.AdminComment.Buffer != NULL)
5630 midl_user_free(InfoBuffer->General.AdminComment.Buffer);
5631
5632 if (InfoBuffer->General.UserComment.Buffer != NULL)
5633 midl_user_free(InfoBuffer->General.UserComment.Buffer);
5634
5635 midl_user_free(InfoBuffer);
5636 }
5637 }
5638
5639 return Status;
5640}
5641
5642
5643static
5644NTSTATUS
5645SampQueryUserPreferences(PSAM_DB_OBJECT UserObject,
5646 PSAMPR_USER_INFO_BUFFER *Buffer)
5647{
5648 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
5649 SAM_USER_FIXED_DATA FixedData;
5650 ULONG Length = 0;
5651 NTSTATUS Status;
5652
5653 *Buffer = NULL;
5654
5655 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
5656 if (InfoBuffer == NULL)
5657 return STATUS_INSUFFICIENT_RESOURCES;
5658
5659 Length = sizeof(SAM_USER_FIXED_DATA);
5660 Status = SampGetObjectAttribute(UserObject,
5661 L"F",
5662 NULL,
5663 (PVOID)&FixedData,
5664 &Length);
5665 if (!NT_SUCCESS(Status))
5666 goto done;
5667
5668 InfoBuffer->Preferences.CountryCode = FixedData.CountryCode;
5669 InfoBuffer->Preferences.CodePage = FixedData.CodePage;
5670
5671 /* Get the UserComment string */
5672 Status = SampGetObjectAttributeString(UserObject,
5673 L"UserComment",
5674 &InfoBuffer->Preferences.UserComment);
5675 if (!NT_SUCCESS(Status))
5676 {
5677 TRACE("Status 0x%08lx\n", Status);
5678 goto done;
5679 }
5680
5681 *Buffer = InfoBuffer;
5682
5683done:
5684 if (!NT_SUCCESS(Status))
5685 {
5686 if (InfoBuffer != NULL)
5687 {
5688 if (InfoBuffer->Preferences.UserComment.Buffer != NULL)
5689 midl_user_free(InfoBuffer->Preferences.UserComment.Buffer);
5690
5691 midl_user_free(InfoBuffer);
5692 }
5693 }
5694
5695 return Status;
5696}
5697
5698
5699static
5700NTSTATUS
5701SampQueryUserLogon(PSAM_DB_OBJECT UserObject,
5702 PSAMPR_USER_INFO_BUFFER *Buffer)
5703{
5704 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
5705 SAM_DOMAIN_FIXED_DATA DomainFixedData;
5706 SAM_USER_FIXED_DATA FixedData;
5707 LARGE_INTEGER PasswordCanChange;
5708 LARGE_INTEGER PasswordMustChange;
5709 ULONG Length = 0;
5710 NTSTATUS Status;
5711
5712 *Buffer = NULL;
5713
5714 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
5715 if (InfoBuffer == NULL)
5716 return STATUS_INSUFFICIENT_RESOURCES;
5717
5718 /* Get the fixed size domain data */
5719 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
5720 Status = SampGetObjectAttribute(UserObject->ParentObject,
5721 L"F",
5722 NULL,
5723 (PVOID)&DomainFixedData,
5724 &Length);
5725 if (!NT_SUCCESS(Status))
5726 goto done;
5727
5728 /* Get the fixed size user data */
5729 Length = sizeof(SAM_USER_FIXED_DATA);
5730 Status = SampGetObjectAttribute(UserObject,
5731 L"F",
5732 NULL,
5733 (PVOID)&FixedData,
5734 &Length);
5735 if (!NT_SUCCESS(Status))
5736 goto done;
5737
5738 InfoBuffer->Logon.UserId = FixedData.UserId;
5739 InfoBuffer->Logon.PrimaryGroupId = FixedData.PrimaryGroupId;
5740 InfoBuffer->Logon.LastLogon.LowPart = FixedData.LastLogon.LowPart;
5741 InfoBuffer->Logon.LastLogon.HighPart = FixedData.LastLogon.HighPart;
5742 InfoBuffer->Logon.LastLogoff.LowPart = FixedData.LastLogoff.LowPart;
5743 InfoBuffer->Logon.LastLogoff.HighPart = FixedData.LastLogoff.HighPart;
5744 InfoBuffer->Logon.PasswordLastSet.LowPart = FixedData.PasswordLastSet.LowPart;
5745 InfoBuffer->Logon.PasswordLastSet.HighPart = FixedData.PasswordLastSet.HighPart;
5746 InfoBuffer->Logon.BadPasswordCount = FixedData.BadPasswordCount;
5747 InfoBuffer->Logon.LogonCount = FixedData.LogonCount;
5748 InfoBuffer->Logon.UserAccountControl = FixedData.UserAccountControl;
5749
5750 PasswordCanChange = SampAddRelativeTimeToTime(FixedData.PasswordLastSet,
5751 DomainFixedData.MinPasswordAge);
5752 InfoBuffer->Logon.PasswordCanChange.LowPart = PasswordCanChange.LowPart;
5753 InfoBuffer->Logon.PasswordCanChange.HighPart = PasswordCanChange.HighPart;
5754
5755 PasswordMustChange = SampAddRelativeTimeToTime(FixedData.PasswordLastSet,
5756 DomainFixedData.MaxPasswordAge);
5757 InfoBuffer->Logon.PasswordMustChange.LowPart = PasswordMustChange.LowPart;
5758 InfoBuffer->Logon.PasswordMustChange.HighPart = PasswordMustChange.HighPart;
5759
5760 /* Get the Name string */
5761 Status = SampGetObjectAttributeString(UserObject,
5762 L"Name",
5763 &InfoBuffer->Logon.UserName);
5764 if (!NT_SUCCESS(Status))
5765 {
5766 TRACE("Status 0x%08lx\n", Status);
5767 goto done;
5768 }
5769
5770 /* Get the FullName string */
5771 Status = SampGetObjectAttributeString(UserObject,
5772 L"FullName",
5773 &InfoBuffer->Logon.FullName);
5774 if (!NT_SUCCESS(Status))
5775 {
5776 TRACE("Status 0x%08lx\n", Status);
5777 goto done;
5778 }
5779
5780 /* Get the HomeDirectory string */
5781 Status = SampGetObjectAttributeString(UserObject,
5782 L"HomeDirectory",
5783 &InfoBuffer->Logon.HomeDirectory);
5784 if (!NT_SUCCESS(Status))
5785 {
5786 TRACE("Status 0x%08lx\n", Status);
5787 goto done;
5788 }
5789
5790 /* Get the HomeDirectoryDrive string */
5791 Status = SampGetObjectAttributeString(UserObject,
5792 L"HomeDirectoryDrive",
5793 &InfoBuffer->Logon.HomeDirectoryDrive);
5794 if (!NT_SUCCESS(Status))
5795 {
5796 TRACE("Status 0x%08lx\n", Status);
5797 goto done;
5798 }
5799
5800 /* Get the ScriptPath string */
5801 Status = SampGetObjectAttributeString(UserObject,
5802 L"ScriptPath",
5803 &InfoBuffer->Logon.ScriptPath);
5804 if (!NT_SUCCESS(Status))
5805 {
5806 TRACE("Status 0x%08lx\n", Status);
5807 goto done;
5808 }
5809
5810 /* Get the ProfilePath string */
5811 Status = SampGetObjectAttributeString(UserObject,
5812 L"ProfilePath",
5813 &InfoBuffer->Logon.ProfilePath);
5814 if (!NT_SUCCESS(Status))
5815 {
5816 TRACE("Status 0x%08lx\n", Status);
5817 goto done;
5818 }
5819
5820 /* Get the WorkStations string */
5821 Status = SampGetObjectAttributeString(UserObject,
5822 L"WorkStations",
5823 &InfoBuffer->Logon.WorkStations);
5824 if (!NT_SUCCESS(Status))
5825 {
5826 TRACE("Status 0x%08lx\n", Status);
5827 goto done;
5828 }
5829
5830 /* Get the LogonHours attribute */
5831 Status = SampGetLogonHoursAttribute(UserObject,
5832 &InfoBuffer->Logon.LogonHours);
5833 if (!NT_SUCCESS(Status))
5834 {
5835 TRACE("Status 0x%08lx\n", Status);
5836 goto done;
5837 }
5838
5839 *Buffer = InfoBuffer;
5840
5841done:
5842 if (!NT_SUCCESS(Status))
5843 {
5844 if (InfoBuffer != NULL)
5845 {
5846 if (InfoBuffer->Logon.UserName.Buffer != NULL)
5847 midl_user_free(InfoBuffer->Logon.UserName.Buffer);
5848
5849 if (InfoBuffer->Logon.FullName.Buffer != NULL)
5850 midl_user_free(InfoBuffer->Logon.FullName.Buffer);
5851
5852 if (InfoBuffer->Logon.HomeDirectory.Buffer != NULL)
5853 midl_user_free(InfoBuffer->Logon.HomeDirectory.Buffer);
5854
5855 if (InfoBuffer->Logon.HomeDirectoryDrive.Buffer != NULL)
5856 midl_user_free(InfoBuffer->Logon.HomeDirectoryDrive.Buffer);
5857
5858 if (InfoBuffer->Logon.ScriptPath.Buffer != NULL)
5859 midl_user_free(InfoBuffer->Logon.ScriptPath.Buffer);
5860
5861 if (InfoBuffer->Logon.ProfilePath.Buffer != NULL)
5862 midl_user_free(InfoBuffer->Logon.ProfilePath.Buffer);
5863
5864 if (InfoBuffer->Logon.WorkStations.Buffer != NULL)
5865 midl_user_free(InfoBuffer->Logon.WorkStations.Buffer);
5866
5867 if (InfoBuffer->Logon.LogonHours.LogonHours != NULL)
5868 midl_user_free(InfoBuffer->Logon.LogonHours.LogonHours);
5869
5870 midl_user_free(InfoBuffer);
5871 }
5872 }
5873
5874 return Status;
5875}
5876
5877
5878static
5879NTSTATUS
5880SampQueryUserAccount(PSAM_DB_OBJECT UserObject,
5881 PSAMPR_USER_INFO_BUFFER *Buffer)
5882{
5883 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
5884 SAM_USER_FIXED_DATA FixedData;
5885 ULONG Length = 0;
5886 NTSTATUS Status;
5887
5888 *Buffer = NULL;
5889
5890 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
5891 if (InfoBuffer == NULL)
5892 return STATUS_INSUFFICIENT_RESOURCES;
5893
5894 Length = sizeof(SAM_USER_FIXED_DATA);
5895 Status = SampGetObjectAttribute(UserObject,
5896 L"F",
5897 NULL,
5898 (PVOID)&FixedData,
5899 &Length);
5900 if (!NT_SUCCESS(Status))
5901 goto done;
5902
5903 InfoBuffer->Account.UserId = FixedData.UserId;
5904 InfoBuffer->Account.PrimaryGroupId = FixedData.PrimaryGroupId;
5905 InfoBuffer->Account.LastLogon.LowPart = FixedData.LastLogon.LowPart;
5906 InfoBuffer->Account.LastLogon.HighPart = FixedData.LastLogon.HighPart;
5907 InfoBuffer->Account.LastLogoff.LowPart = FixedData.LastLogoff.LowPart;
5908 InfoBuffer->Account.LastLogoff.HighPart = FixedData.LastLogoff.HighPart;
5909 InfoBuffer->Account.PasswordLastSet.LowPart = FixedData.PasswordLastSet.LowPart;
5910 InfoBuffer->Account.PasswordLastSet.HighPart = FixedData.PasswordLastSet.HighPart;
5911 InfoBuffer->Account.AccountExpires.LowPart = FixedData.AccountExpires.LowPart;
5912 InfoBuffer->Account.AccountExpires.HighPart = FixedData.AccountExpires.HighPart;
5913 InfoBuffer->Account.BadPasswordCount = FixedData.BadPasswordCount;
5914 InfoBuffer->Account.LogonCount = FixedData.LogonCount;
5915 InfoBuffer->Account.UserAccountControl = FixedData.UserAccountControl;
5916
5917 /* Get the Name string */
5918 Status = SampGetObjectAttributeString(UserObject,
5919 L"Name",
5920 &InfoBuffer->Account.UserName);
5921 if (!NT_SUCCESS(Status))
5922 {
5923 TRACE("Status 0x%08lx\n", Status);
5924 goto done;
5925 }
5926
5927 /* Get the FullName string */
5928 Status = SampGetObjectAttributeString(UserObject,
5929 L"FullName",
5930 &InfoBuffer->Account.FullName);
5931 if (!NT_SUCCESS(Status))
5932 {
5933 TRACE("Status 0x%08lx\n", Status);
5934 goto done;
5935 }
5936
5937 /* Get the HomeDirectory string */
5938 Status = SampGetObjectAttributeString(UserObject,
5939 L"HomeDirectory",
5940 &InfoBuffer->Account.HomeDirectory);
5941 if (!NT_SUCCESS(Status))
5942 {
5943 TRACE("Status 0x%08lx\n", Status);
5944 goto done;
5945 }
5946
5947 /* Get the HomeDirectoryDrive string */
5948 Status = SampGetObjectAttributeString(UserObject,
5949 L"HomeDirectoryDrive",
5950 &InfoBuffer->Account.HomeDirectoryDrive);
5951 if (!NT_SUCCESS(Status))
5952 {
5953 TRACE("Status 0x%08lx\n", Status);
5954 goto done;
5955 }
5956
5957 /* Get the ScriptPath string */
5958 Status = SampGetObjectAttributeString(UserObject,
5959 L"ScriptPath",
5960 &InfoBuffer->Account.ScriptPath);
5961 if (!NT_SUCCESS(Status))
5962 {
5963 TRACE("Status 0x%08lx\n", Status);
5964 goto done;
5965 }
5966
5967 /* Get the ProfilePath string */
5968 Status = SampGetObjectAttributeString(UserObject,
5969 L"ProfilePath",
5970 &InfoBuffer->Account.ProfilePath);
5971 if (!NT_SUCCESS(Status))
5972 {
5973 TRACE("Status 0x%08lx\n", Status);
5974 goto done;
5975 }
5976
5977 /* Get the AdminComment string */
5978 Status = SampGetObjectAttributeString(UserObject,
5979 L"AdminComment",
5980 &InfoBuffer->Account.AdminComment);
5981 if (!NT_SUCCESS(Status))
5982 {
5983 TRACE("Status 0x%08lx\n", Status);
5984 goto done;
5985 }
5986
5987 /* Get the WorkStations string */
5988 Status = SampGetObjectAttributeString(UserObject,
5989 L"WorkStations",
5990 &InfoBuffer->Account.WorkStations);
5991 if (!NT_SUCCESS(Status))
5992 {
5993 TRACE("Status 0x%08lx\n", Status);
5994 goto done;
5995 }
5996
5997 /* Get the LogonHours attribute */
5998 Status = SampGetLogonHoursAttribute(UserObject,
5999 &InfoBuffer->Account.LogonHours);
6000 if (!NT_SUCCESS(Status))
6001 {
6002 TRACE("Status 0x%08lx\n", Status);
6003 goto done;
6004 }
6005
6006 *Buffer = InfoBuffer;
6007
6008done:
6009 if (!NT_SUCCESS(Status))
6010 {
6011 if (InfoBuffer != NULL)
6012 {
6013 if (InfoBuffer->Account.UserName.Buffer != NULL)
6014 midl_user_free(InfoBuffer->Account.UserName.Buffer);
6015
6016 if (InfoBuffer->Account.FullName.Buffer != NULL)
6017 midl_user_free(InfoBuffer->Account.FullName.Buffer);
6018
6019 if (InfoBuffer->Account.HomeDirectory.Buffer != NULL)
6020 midl_user_free(InfoBuffer->Account.HomeDirectory.Buffer);
6021
6022 if (InfoBuffer->Account.HomeDirectoryDrive.Buffer != NULL)
6023 midl_user_free(InfoBuffer->Account.HomeDirectoryDrive.Buffer);
6024
6025 if (InfoBuffer->Account.ScriptPath.Buffer != NULL)
6026 midl_user_free(InfoBuffer->Account.ScriptPath.Buffer);
6027
6028 if (InfoBuffer->Account.ProfilePath.Buffer != NULL)
6029 midl_user_free(InfoBuffer->Account.ProfilePath.Buffer);
6030
6031 if (InfoBuffer->Account.AdminComment.Buffer != NULL)
6032 midl_user_free(InfoBuffer->Account.AdminComment.Buffer);
6033
6034 if (InfoBuffer->Account.WorkStations.Buffer != NULL)
6035 midl_user_free(InfoBuffer->Account.WorkStations.Buffer);
6036
6037 if (InfoBuffer->Account.LogonHours.LogonHours != NULL)
6038 midl_user_free(InfoBuffer->Account.LogonHours.LogonHours);
6039
6040 midl_user_free(InfoBuffer);
6041 }
6042 }
6043
6044 return Status;
6045}
6046
6047
6048static
6049NTSTATUS
6050SampQueryUserLogonHours(PSAM_DB_OBJECT UserObject,
6051 PSAMPR_USER_INFO_BUFFER *Buffer)
6052{
6053 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6054 NTSTATUS Status;
6055
6056 TRACE("(%p %p)\n", UserObject, Buffer);
6057
6058 *Buffer = NULL;
6059
6060 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6061 if (InfoBuffer == NULL)
6062 {
6063 TRACE("Failed to allocate InfoBuffer!\n");
6064 return STATUS_INSUFFICIENT_RESOURCES;
6065 }
6066
6067 Status = SampGetLogonHoursAttribute(UserObject,
6068 &InfoBuffer->LogonHours.LogonHours);
6069 if (!NT_SUCCESS(Status))
6070 {
6071 TRACE("SampGetLogonHoursAttribute failed (Status 0x%08lx)\n", Status);
6072 goto done;
6073 }
6074
6075 *Buffer = InfoBuffer;
6076
6077done:
6078 if (!NT_SUCCESS(Status))
6079 {
6080 if (InfoBuffer != NULL)
6081 {
6082 if (InfoBuffer->LogonHours.LogonHours.LogonHours != NULL)
6083 midl_user_free(InfoBuffer->LogonHours.LogonHours.LogonHours);
6084
6085 midl_user_free(InfoBuffer);
6086 }
6087 }
6088
6089 return Status;
6090}
6091
6092
6093static
6094NTSTATUS
6095SampQueryUserName(PSAM_DB_OBJECT UserObject,
6096 PSAMPR_USER_INFO_BUFFER *Buffer)
6097{
6098 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6099 NTSTATUS Status;
6100
6101 *Buffer = NULL;
6102
6103 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6104 if (InfoBuffer == NULL)
6105 return STATUS_INSUFFICIENT_RESOURCES;
6106
6107 /* Get the Name string */
6108 Status = SampGetObjectAttributeString(UserObject,
6109 L"Name",
6110 &InfoBuffer->Name.UserName);
6111 if (!NT_SUCCESS(Status))
6112 {
6113 TRACE("Status 0x%08lx\n", Status);
6114 goto done;
6115 }
6116
6117 /* Get the FullName string */
6118 Status = SampGetObjectAttributeString(UserObject,
6119 L"FullName",
6120 &InfoBuffer->Name.FullName);
6121 if (!NT_SUCCESS(Status))
6122 {
6123 TRACE("Status 0x%08lx\n", Status);
6124 goto done;
6125 }
6126
6127 *Buffer = InfoBuffer;
6128
6129done:
6130 if (!NT_SUCCESS(Status))
6131 {
6132 if (InfoBuffer != NULL)
6133 {
6134 if (InfoBuffer->Name.UserName.Buffer != NULL)
6135 midl_user_free(InfoBuffer->Name.UserName.Buffer);
6136
6137 if (InfoBuffer->Name.FullName.Buffer != NULL)
6138 midl_user_free(InfoBuffer->Name.FullName.Buffer);
6139
6140 midl_user_free(InfoBuffer);
6141 }
6142 }
6143
6144 return Status;
6145}
6146
6147
6148static NTSTATUS
6149SampQueryUserAccountName(PSAM_DB_OBJECT UserObject,
6150 PSAMPR_USER_INFO_BUFFER *Buffer)
6151{
6152 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6153 NTSTATUS Status;
6154
6155 *Buffer = NULL;
6156
6157 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6158 if (InfoBuffer == NULL)
6159 return STATUS_INSUFFICIENT_RESOURCES;
6160
6161 /* Get the Name string */
6162 Status = SampGetObjectAttributeString(UserObject,
6163 L"Name",
6164 &InfoBuffer->AccountName.UserName);
6165 if (!NT_SUCCESS(Status))
6166 {
6167 TRACE("Status 0x%08lx\n", Status);
6168 goto done;
6169 }
6170
6171 *Buffer = InfoBuffer;
6172
6173done:
6174 if (!NT_SUCCESS(Status))
6175 {
6176 if (InfoBuffer != NULL)
6177 {
6178 if (InfoBuffer->AccountName.UserName.Buffer != NULL)
6179 midl_user_free(InfoBuffer->AccountName.UserName.Buffer);
6180
6181 midl_user_free(InfoBuffer);
6182 }
6183 }
6184
6185 return Status;
6186}
6187
6188
6189static NTSTATUS
6190SampQueryUserFullName(PSAM_DB_OBJECT UserObject,
6191 PSAMPR_USER_INFO_BUFFER *Buffer)
6192{
6193 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6194 NTSTATUS Status;
6195
6196 *Buffer = NULL;
6197
6198 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6199 if (InfoBuffer == NULL)
6200 return STATUS_INSUFFICIENT_RESOURCES;
6201
6202 /* Get the FullName string */
6203 Status = SampGetObjectAttributeString(UserObject,
6204 L"FullName",
6205 &InfoBuffer->FullName.FullName);
6206 if (!NT_SUCCESS(Status))
6207 {
6208 TRACE("Status 0x%08lx\n", Status);
6209 goto done;
6210 }
6211
6212 *Buffer = InfoBuffer;
6213
6214done:
6215 if (!NT_SUCCESS(Status))
6216 {
6217 if (InfoBuffer != NULL)
6218 {
6219 if (InfoBuffer->FullName.FullName.Buffer != NULL)
6220 midl_user_free(InfoBuffer->FullName.FullName.Buffer);
6221
6222 midl_user_free(InfoBuffer);
6223 }
6224 }
6225
6226 return Status;
6227}
6228
6229
6230static
6231NTSTATUS
6232SampQueryUserPrimaryGroup(PSAM_DB_OBJECT UserObject,
6233 PSAMPR_USER_INFO_BUFFER *Buffer)
6234{
6235 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6236 SAM_USER_FIXED_DATA FixedData;
6237 ULONG Length = 0;
6238 NTSTATUS Status;
6239
6240 *Buffer = NULL;
6241
6242 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6243 if (InfoBuffer == NULL)
6244 return STATUS_INSUFFICIENT_RESOURCES;
6245
6246 Length = sizeof(SAM_USER_FIXED_DATA);
6247 Status = SampGetObjectAttribute(UserObject,
6248 L"F",
6249 NULL,
6250 (PVOID)&FixedData,
6251 &Length);
6252 if (!NT_SUCCESS(Status))
6253 goto done;
6254
6255 InfoBuffer->PrimaryGroup.PrimaryGroupId = FixedData.PrimaryGroupId;
6256
6257 *Buffer = InfoBuffer;
6258
6259done:
6260 if (!NT_SUCCESS(Status))
6261 {
6262 if (InfoBuffer != NULL)
6263 {
6264 midl_user_free(InfoBuffer);
6265 }
6266 }
6267
6268 return Status;
6269}
6270
6271
6272static NTSTATUS
6273SampQueryUserHome(PSAM_DB_OBJECT UserObject,
6274 PSAMPR_USER_INFO_BUFFER *Buffer)
6275{
6276 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6277 NTSTATUS Status;
6278
6279 *Buffer = NULL;
6280
6281 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6282 if (InfoBuffer == NULL)
6283 return STATUS_INSUFFICIENT_RESOURCES;
6284
6285 /* Get the HomeDirectory string */
6286 Status = SampGetObjectAttributeString(UserObject,
6287 L"HomeDirectory",
6288 &InfoBuffer->Home.HomeDirectory);
6289 if (!NT_SUCCESS(Status))
6290 {
6291 TRACE("Status 0x%08lx\n", Status);
6292 goto done;
6293 }
6294
6295 /* Get the HomeDirectoryDrive string */
6296 Status = SampGetObjectAttributeString(UserObject,
6297 L"HomeDirectoryDrive",
6298 &InfoBuffer->Home.HomeDirectoryDrive);
6299 if (!NT_SUCCESS(Status))
6300 {
6301 TRACE("Status 0x%08lx\n", Status);
6302 goto done;
6303 }
6304
6305 *Buffer = InfoBuffer;
6306
6307done:
6308 if (!NT_SUCCESS(Status))
6309 {
6310 if (InfoBuffer != NULL)
6311 {
6312 if (InfoBuffer->Home.HomeDirectory.Buffer != NULL)
6313 midl_user_free(InfoBuffer->Home.HomeDirectory.Buffer);
6314
6315 if (InfoBuffer->Home.HomeDirectoryDrive.Buffer != NULL)
6316 midl_user_free(InfoBuffer->Home.HomeDirectoryDrive.Buffer);
6317
6318 midl_user_free(InfoBuffer);
6319 }
6320 }
6321
6322 return Status;
6323}
6324
6325
6326static NTSTATUS
6327SampQueryUserScript(PSAM_DB_OBJECT UserObject,
6328 PSAMPR_USER_INFO_BUFFER *Buffer)
6329{
6330 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6331 NTSTATUS Status;
6332
6333 *Buffer = NULL;
6334
6335 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6336 if (InfoBuffer == NULL)
6337 return STATUS_INSUFFICIENT_RESOURCES;
6338
6339 /* Get the ScriptPath string */
6340 Status = SampGetObjectAttributeString(UserObject,
6341 L"ScriptPath",
6342 &InfoBuffer->Script.ScriptPath);
6343 if (!NT_SUCCESS(Status))
6344 {
6345 TRACE("Status 0x%08lx\n", Status);
6346 goto done;
6347 }
6348
6349 *Buffer = InfoBuffer;
6350
6351done:
6352 if (!NT_SUCCESS(Status))
6353 {
6354 if (InfoBuffer != NULL)
6355 {
6356 if (InfoBuffer->Script.ScriptPath.Buffer != NULL)
6357 midl_user_free(InfoBuffer->Script.ScriptPath.Buffer);
6358
6359 midl_user_free(InfoBuffer);
6360 }
6361 }
6362
6363 return Status;
6364}
6365
6366
6367static NTSTATUS
6368SampQueryUserProfile(PSAM_DB_OBJECT UserObject,
6369 PSAMPR_USER_INFO_BUFFER *Buffer)
6370{
6371 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6372 NTSTATUS Status;
6373
6374 *Buffer = NULL;
6375
6376 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6377 if (InfoBuffer == NULL)
6378 return STATUS_INSUFFICIENT_RESOURCES;
6379
6380 /* Get the ProfilePath string */
6381 Status = SampGetObjectAttributeString(UserObject,
6382 L"ProfilePath",
6383 &InfoBuffer->Profile.ProfilePath);
6384 if (!NT_SUCCESS(Status))
6385 {
6386 TRACE("Status 0x%08lx\n", Status);
6387 goto done;
6388 }
6389
6390 *Buffer = InfoBuffer;
6391
6392done:
6393 if (!NT_SUCCESS(Status))
6394 {
6395 if (InfoBuffer != NULL)
6396 {
6397 if (InfoBuffer->Profile.ProfilePath.Buffer != NULL)
6398 midl_user_free(InfoBuffer->Profile.ProfilePath.Buffer);
6399
6400 midl_user_free(InfoBuffer);
6401 }
6402 }
6403
6404 return Status;
6405}
6406
6407
6408static NTSTATUS
6409SampQueryUserAdminComment(PSAM_DB_OBJECT UserObject,
6410 PSAMPR_USER_INFO_BUFFER *Buffer)
6411{
6412 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6413 NTSTATUS Status;
6414
6415 *Buffer = NULL;
6416
6417 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6418 if (InfoBuffer == NULL)
6419 return STATUS_INSUFFICIENT_RESOURCES;
6420
6421 /* Get the AdminComment string */
6422 Status = SampGetObjectAttributeString(UserObject,
6423 L"AdminComment",
6424 &InfoBuffer->AdminComment.AdminComment);
6425 if (!NT_SUCCESS(Status))
6426 {
6427 TRACE("Status 0x%08lx\n", Status);
6428 goto done;
6429 }
6430
6431 *Buffer = InfoBuffer;
6432
6433done:
6434 if (!NT_SUCCESS(Status))
6435 {
6436 if (InfoBuffer != NULL)
6437 {
6438 if (InfoBuffer->AdminComment.AdminComment.Buffer != NULL)
6439 midl_user_free(InfoBuffer->AdminComment.AdminComment.Buffer);
6440
6441 midl_user_free(InfoBuffer);
6442 }
6443 }
6444
6445 return Status;
6446}
6447
6448
6449static NTSTATUS
6450SampQueryUserWorkStations(PSAM_DB_OBJECT UserObject,
6451 PSAMPR_USER_INFO_BUFFER *Buffer)
6452{
6453 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6454 NTSTATUS Status;
6455
6456 *Buffer = NULL;
6457
6458 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6459 if (InfoBuffer == NULL)
6460 return STATUS_INSUFFICIENT_RESOURCES;
6461
6462 /* Get the WorkStations string */
6463 Status = SampGetObjectAttributeString(UserObject,
6464 L"WorkStations",
6465 &InfoBuffer->WorkStations.WorkStations);
6466 if (!NT_SUCCESS(Status))
6467 {
6468 TRACE("Status 0x%08lx\n", Status);
6469 goto done;
6470 }
6471
6472 *Buffer = InfoBuffer;
6473
6474done:
6475 if (!NT_SUCCESS(Status))
6476 {
6477 if (InfoBuffer != NULL)
6478 {
6479 if (InfoBuffer->WorkStations.WorkStations.Buffer != NULL)
6480 midl_user_free(InfoBuffer->WorkStations.WorkStations.Buffer);
6481
6482 midl_user_free(InfoBuffer);
6483 }
6484 }
6485
6486 return Status;
6487}
6488
6489
6490static
6491NTSTATUS
6492SampQueryUserControl(PSAM_DB_OBJECT UserObject,
6493 PSAMPR_USER_INFO_BUFFER *Buffer)
6494{
6495 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6496 SAM_USER_FIXED_DATA FixedData;
6497 ULONG Length = 0;
6498 NTSTATUS Status;
6499
6500 *Buffer = NULL;
6501
6502 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6503 if (InfoBuffer == NULL)
6504 return STATUS_INSUFFICIENT_RESOURCES;
6505
6506 Length = sizeof(SAM_USER_FIXED_DATA);
6507 Status = SampGetObjectAttribute(UserObject,
6508 L"F",
6509 NULL,
6510 (PVOID)&FixedData,
6511 &Length);
6512 if (!NT_SUCCESS(Status))
6513 goto done;
6514
6515 InfoBuffer->Control.UserAccountControl = FixedData.UserAccountControl;
6516
6517 *Buffer = InfoBuffer;
6518
6519done:
6520 if (!NT_SUCCESS(Status))
6521 {
6522 if (InfoBuffer != NULL)
6523 {
6524 midl_user_free(InfoBuffer);
6525 }
6526 }
6527
6528 return Status;
6529}
6530
6531
6532static
6533NTSTATUS
6534SampQueryUserExpires(PSAM_DB_OBJECT UserObject,
6535 PSAMPR_USER_INFO_BUFFER *Buffer)
6536{
6537 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6538 SAM_USER_FIXED_DATA FixedData;
6539 ULONG Length = 0;
6540 NTSTATUS Status;
6541
6542 *Buffer = NULL;
6543
6544 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6545 if (InfoBuffer == NULL)
6546 return STATUS_INSUFFICIENT_RESOURCES;
6547
6548 Length = sizeof(SAM_USER_FIXED_DATA);
6549 Status = SampGetObjectAttribute(UserObject,
6550 L"F",
6551 NULL,
6552 (PVOID)&FixedData,
6553 &Length);
6554 if (!NT_SUCCESS(Status))
6555 goto done;
6556
6557 InfoBuffer->Expires.AccountExpires.LowPart = FixedData.AccountExpires.LowPart;
6558 InfoBuffer->Expires.AccountExpires.HighPart = FixedData.AccountExpires.HighPart;
6559
6560 *Buffer = InfoBuffer;
6561
6562done:
6563 if (!NT_SUCCESS(Status))
6564 {
6565 if (InfoBuffer != NULL)
6566 {
6567 midl_user_free(InfoBuffer);
6568 }
6569 }
6570
6571 return Status;
6572}
6573
6574
6575static
6576NTSTATUS
6577SampQueryUserInternal1(PSAM_DB_OBJECT UserObject,
6578 PSAMPR_USER_INFO_BUFFER *Buffer)
6579{
6580 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6581 ULONG Length = 0;
6582 NTSTATUS Status = STATUS_SUCCESS;
6583
6584 /* Fail, if the caller is not a trusted caller */
6585 if (UserObject->Trusted == FALSE)
6586 return STATUS_INVALID_INFO_CLASS;
6587
6588 *Buffer = NULL;
6589
6590 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6591 if (InfoBuffer == NULL)
6592 return STATUS_INSUFFICIENT_RESOURCES;
6593
6594 InfoBuffer->Internal1.LmPasswordPresent = FALSE;
6595 InfoBuffer->Internal1.NtPasswordPresent = FALSE;
6596
6597 /* Get the NT password */
6598 Length = 0;
6599 SampGetObjectAttribute(UserObject,
6600 L"NTPwd",
6601 NULL,
6602 NULL,
6603 &Length);
6604
6605 if (Length == sizeof(ENCRYPTED_NT_OWF_PASSWORD))
6606 {
6607 Status = SampGetObjectAttribute(UserObject,
6608 L"NTPwd",
6609 NULL,
6610 (PVOID)&InfoBuffer->Internal1.EncryptedNtOwfPassword,
6611 &Length);
6612 if (!NT_SUCCESS(Status))
6613 goto done;
6614
6615 if (memcmp(&InfoBuffer->Internal1.EncryptedNtOwfPassword,
6616 &EmptyNtHash,
6617 sizeof(ENCRYPTED_NT_OWF_PASSWORD)))
6618 InfoBuffer->Internal1.NtPasswordPresent = TRUE;
6619 }
6620
6621
6622 /* Get the LM password */
6623 Length = 0;
6624 SampGetObjectAttribute(UserObject,
6625 L"LMPwd",
6626 NULL,
6627 NULL,
6628 &Length);
6629
6630 if (Length == sizeof(ENCRYPTED_LM_OWF_PASSWORD))
6631 {
6632 Status = SampGetObjectAttribute(UserObject,
6633 L"LMPwd",
6634 NULL,
6635 (PVOID)&InfoBuffer->Internal1.EncryptedLmOwfPassword,
6636 &Length);
6637 if (!NT_SUCCESS(Status))
6638 goto done;
6639
6640 if (memcmp(&InfoBuffer->Internal1.EncryptedLmOwfPassword,
6641 &EmptyLmHash,
6642 sizeof(ENCRYPTED_LM_OWF_PASSWORD)))
6643 InfoBuffer->Internal1.LmPasswordPresent = TRUE;
6644 }
6645
6646 InfoBuffer->Internal1.PasswordExpired = FALSE;
6647
6648 *Buffer = InfoBuffer;
6649
6650done:
6651 if (!NT_SUCCESS(Status))
6652 {
6653 if (InfoBuffer != NULL)
6654 {
6655 midl_user_free(InfoBuffer);
6656 }
6657 }
6658
6659 return Status;
6660}
6661
6662
6663static
6664NTSTATUS
6665SampQueryUserInternal2(PSAM_DB_OBJECT UserObject,
6666 PSAMPR_USER_INFO_BUFFER *Buffer)
6667{
6668 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6669 SAM_USER_FIXED_DATA FixedData;
6670 ULONG Length = 0;
6671 NTSTATUS Status;
6672
6673 *Buffer = NULL;
6674
6675 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6676 if (InfoBuffer == NULL)
6677 return STATUS_INSUFFICIENT_RESOURCES;
6678
6679 Length = sizeof(SAM_USER_FIXED_DATA);
6680 Status = SampGetObjectAttribute(UserObject,
6681 L"F",
6682 NULL,
6683 (PVOID)&FixedData,
6684 &Length);
6685 if (!NT_SUCCESS(Status))
6686 goto done;
6687
6688 InfoBuffer->Internal2.Flags = 0;
6689 InfoBuffer->Internal2.LastLogon.LowPart = FixedData.LastLogon.LowPart;
6690 InfoBuffer->Internal2.LastLogon.HighPart = FixedData.LastLogon.HighPart;
6691 InfoBuffer->Internal2.LastLogoff.LowPart = FixedData.LastLogoff.LowPart;
6692 InfoBuffer->Internal2.LastLogoff.HighPart = FixedData.LastLogoff.HighPart;
6693 InfoBuffer->Internal2.BadPasswordCount = FixedData.BadPasswordCount;
6694 InfoBuffer->Internal2.LogonCount = FixedData.LogonCount;
6695
6696 *Buffer = InfoBuffer;
6697
6698done:
6699 if (!NT_SUCCESS(Status))
6700 {
6701 if (InfoBuffer != NULL)
6702 {
6703 midl_user_free(InfoBuffer);
6704 }
6705 }
6706
6707 return Status;
6708}
6709
6710
6711static NTSTATUS
6712SampQueryUserParameters(PSAM_DB_OBJECT UserObject,
6713 PSAMPR_USER_INFO_BUFFER *Buffer)
6714{
6715 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6716 NTSTATUS Status;
6717
6718 *Buffer = NULL;
6719
6720 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6721 if (InfoBuffer == NULL)
6722 return STATUS_INSUFFICIENT_RESOURCES;
6723
6724 /* Get the Parameters string */
6725 Status = SampGetObjectAttributeString(UserObject,
6726 L"Parameters",
6727 &InfoBuffer->Parameters.Parameters);
6728 if (!NT_SUCCESS(Status))
6729 {
6730 TRACE("Status 0x%08lx\n", Status);
6731 goto done;
6732 }
6733
6734 *Buffer = InfoBuffer;
6735
6736done:
6737 if (!NT_SUCCESS(Status))
6738 {
6739 if (InfoBuffer != NULL)
6740 {
6741 if (InfoBuffer->Parameters.Parameters.Buffer != NULL)
6742 midl_user_free(InfoBuffer->Parameters.Parameters.Buffer);
6743
6744 midl_user_free(InfoBuffer);
6745 }
6746 }
6747
6748 return Status;
6749}
6750
6751
6752static NTSTATUS
6753SampQueryUserAll(PSAM_DB_OBJECT UserObject,
6754 PSAMPR_USER_INFO_BUFFER *Buffer)
6755{
6756 PSAMPR_USER_INFO_BUFFER InfoBuffer = NULL;
6757 SAM_DOMAIN_FIXED_DATA DomainFixedData;
6758 SAM_USER_FIXED_DATA FixedData;
6759 LARGE_INTEGER PasswordCanChange;
6760 LARGE_INTEGER PasswordMustChange;
6761 ULONG Length = 0;
6762 NTSTATUS Status;
6763
6764 *Buffer = NULL;
6765
6766 InfoBuffer = midl_user_allocate(sizeof(SAMPR_USER_INFO_BUFFER));
6767 if (InfoBuffer == NULL)
6768 return STATUS_INSUFFICIENT_RESOURCES;
6769
6770 /* Get the fixed size domain data */
6771 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
6772 Status = SampGetObjectAttribute(UserObject->ParentObject,
6773 L"F",
6774 NULL,
6775 (PVOID)&DomainFixedData,
6776 &Length);
6777 if (!NT_SUCCESS(Status))
6778 goto done;
6779
6780 /* Get the fixed size user data */
6781 Length = sizeof(SAM_USER_FIXED_DATA);
6782 Status = SampGetObjectAttribute(UserObject,
6783 L"F",
6784 NULL,
6785 (PVOID)&FixedData,
6786 &Length);
6787 if (!NT_SUCCESS(Status))
6788 goto done;
6789
6790 /* Set the fields to be returned */
6791 if (UserObject->Trusted)
6792 {
6793 InfoBuffer->All.WhichFields = USER_ALL_READ_GENERAL_MASK |
6794 USER_ALL_READ_LOGON_MASK |
6795 USER_ALL_READ_ACCOUNT_MASK |
6796 USER_ALL_READ_PREFERENCES_MASK |
6797 USER_ALL_READ_TRUSTED_MASK;
6798 }
6799 else
6800 {
6801 InfoBuffer->All.WhichFields = 0;
6802
6803 if (UserObject->Access & USER_READ_GENERAL)
6804 InfoBuffer->All.WhichFields |= USER_ALL_READ_GENERAL_MASK;
6805
6806 if (UserObject->Access & USER_READ_LOGON)
6807 InfoBuffer->All.WhichFields |= USER_ALL_READ_LOGON_MASK;
6808
6809 if (UserObject->Access & USER_READ_ACCOUNT)
6810 InfoBuffer->All.WhichFields |= USER_ALL_READ_ACCOUNT_MASK;
6811
6812 if (UserObject->Access & USER_READ_PREFERENCES)
6813 InfoBuffer->All.WhichFields |= USER_ALL_READ_PREFERENCES_MASK;
6814 }
6815
6816 /* Fail, if no fields are to be returned */
6817 if (InfoBuffer->All.WhichFields == 0)
6818 {
6819 Status = STATUS_ACCESS_DENIED;
6820 goto done;
6821 }
6822
6823 /* Get the UserName attribute */
6824 if (InfoBuffer->All.WhichFields & USER_ALL_USERNAME)
6825 {
6826 Status = SampGetObjectAttributeString(UserObject,
6827 L"Name",
6828 &InfoBuffer->All.UserName);
6829 if (!NT_SUCCESS(Status))
6830 {
6831 TRACE("Status 0x%08lx\n", Status);
6832 goto done;
6833 }
6834 }
6835
6836 /* Get the FullName attribute */
6837 if (InfoBuffer->All.WhichFields & USER_ALL_FULLNAME)
6838 {
6839 Status = SampGetObjectAttributeString(UserObject,
6840 L"FullName",
6841 &InfoBuffer->All.FullName);
6842 if (!NT_SUCCESS(Status))
6843 {
6844 TRACE("Status 0x%08lx\n", Status);
6845 goto done;
6846 }
6847 }
6848
6849 /* Get the UserId attribute */
6850 if (InfoBuffer->All.WhichFields & USER_ALL_USERID)
6851 {
6852 InfoBuffer->All.UserId = FixedData.UserId;
6853 }
6854
6855 /* Get the PrimaryGroupId attribute */
6856 if (InfoBuffer->All.WhichFields & USER_ALL_PRIMARYGROUPID)
6857 {
6858 InfoBuffer->All.PrimaryGroupId = FixedData.PrimaryGroupId;
6859 }
6860
6861 /* Get the AdminComment attribute */
6862 if (InfoBuffer->All.WhichFields & USER_ALL_ADMINCOMMENT)
6863 {
6864 Status = SampGetObjectAttributeString(UserObject,
6865 L"AdminComment",
6866 &InfoBuffer->All.AdminComment);
6867 if (!NT_SUCCESS(Status))
6868 {
6869 TRACE("Status 0x%08lx\n", Status);
6870 goto done;
6871 }
6872 }
6873
6874 /* Get the UserComment attribute */
6875 if (InfoBuffer->All.WhichFields & USER_ALL_USERCOMMENT)
6876 {
6877 Status = SampGetObjectAttributeString(UserObject,
6878 L"UserComment",
6879 &InfoBuffer->All.UserComment);
6880 if (!NT_SUCCESS(Status))
6881 {
6882 TRACE("Status 0x%08lx\n", Status);
6883 goto done;
6884 }
6885 }
6886
6887 /* Get the HomeDirectory attribute */
6888 if (InfoBuffer->All.WhichFields & USER_ALL_HOMEDIRECTORY)
6889 {
6890 Status = SampGetObjectAttributeString(UserObject,
6891 L"HomeDirectory",
6892 &InfoBuffer->All.HomeDirectory);
6893 if (!NT_SUCCESS(Status))
6894 {
6895 TRACE("Status 0x%08lx\n", Status);
6896 goto done;
6897 }
6898 }
6899
6900 /* Get the HomeDirectoryDrive attribute */
6901 if (InfoBuffer->All.WhichFields & USER_ALL_HOMEDIRECTORYDRIVE)
6902 {
6903 Status = SampGetObjectAttributeString(UserObject,
6904 L"HomeDirectoryDrive",
6905 &InfoBuffer->Home.HomeDirectoryDrive);
6906 if (!NT_SUCCESS(Status))
6907 {
6908 TRACE("Status 0x%08lx\n", Status);
6909 goto done;
6910 }
6911 }
6912
6913 /* Get the ScriptPath attribute */
6914 if (InfoBuffer->All.WhichFields & USER_ALL_SCRIPTPATH)
6915 {
6916 Status = SampGetObjectAttributeString(UserObject,
6917 L"ScriptPath",
6918 &InfoBuffer->All.ScriptPath);
6919 if (!NT_SUCCESS(Status))
6920 {
6921 TRACE("Status 0x%08lx\n", Status);
6922 goto done;
6923 }
6924 }
6925
6926 /* Get the ProfilePath attribute */
6927 if (InfoBuffer->All.WhichFields & USER_ALL_PROFILEPATH)
6928 {
6929 Status = SampGetObjectAttributeString(UserObject,
6930 L"ProfilePath",
6931 &InfoBuffer->All.ProfilePath);
6932 if (!NT_SUCCESS(Status))
6933 {
6934 TRACE("Status 0x%08lx\n", Status);
6935 goto done;
6936 }
6937 }
6938
6939 /* Get the WorkStations attribute */
6940 if (InfoBuffer->All.WhichFields & USER_ALL_WORKSTATIONS)
6941 {
6942 Status = SampGetObjectAttributeString(UserObject,
6943 L"WorkStations",
6944 &InfoBuffer->All.WorkStations);
6945 if (!NT_SUCCESS(Status))
6946 {
6947 TRACE("Status 0x%08lx\n", Status);
6948 goto done;
6949 }
6950 }
6951
6952 /* Get the LastLogon attribute */
6953 if (InfoBuffer->All.WhichFields & USER_ALL_LASTLOGON)
6954 {
6955 InfoBuffer->All.LastLogon.LowPart = FixedData.LastLogon.LowPart;
6956 InfoBuffer->All.LastLogon.HighPart = FixedData.LastLogon.HighPart;
6957 }
6958
6959 /* Get the LastLogoff attribute */
6960 if (InfoBuffer->All.WhichFields & USER_ALL_LASTLOGOFF)
6961 {
6962 InfoBuffer->All.LastLogoff.LowPart = FixedData.LastLogoff.LowPart;
6963 InfoBuffer->All.LastLogoff.HighPart = FixedData.LastLogoff.HighPart;
6964 }
6965
6966 /* Get the LogonHours attribute */
6967 if (InfoBuffer->All.WhichFields & USER_ALL_LOGONHOURS)
6968 {
6969 Status = SampGetLogonHoursAttribute(UserObject,
6970 &InfoBuffer->All.LogonHours);
6971 if (!NT_SUCCESS(Status))
6972 {
6973 TRACE("Status 0x%08lx\n", Status);
6974 goto done;
6975 }
6976 }
6977
6978 /* Get the BadPasswordCount attribute */
6979 if (InfoBuffer->All.WhichFields & USER_ALL_BADPASSWORDCOUNT)
6980 {
6981 InfoBuffer->All.BadPasswordCount = FixedData.BadPasswordCount;
6982 }
6983
6984 /* Get the LogonCount attribute */
6985 if (InfoBuffer->All.WhichFields & USER_ALL_LOGONCOUNT)
6986 {
6987 InfoBuffer->All.LogonCount = FixedData.LogonCount;
6988 }
6989
6990 /* Get the PasswordCanChange attribute */
6991 if (InfoBuffer->All.WhichFields & USER_ALL_PASSWORDCANCHANGE)
6992 {
6993 PasswordCanChange = SampAddRelativeTimeToTime(FixedData.PasswordLastSet,
6994 DomainFixedData.MinPasswordAge);
6995 InfoBuffer->All.PasswordCanChange.LowPart = PasswordCanChange.LowPart;
6996 InfoBuffer->All.PasswordCanChange.HighPart = PasswordCanChange.HighPart;
6997 }
6998
6999 /* Get the PasswordMustChange attribute */
7000 if (InfoBuffer->All.WhichFields & USER_ALL_PASSWORDMUSTCHANGE)
7001 {
7002 PasswordMustChange = SampAddRelativeTimeToTime(FixedData.PasswordLastSet,
7003 DomainFixedData.MaxPasswordAge);
7004 InfoBuffer->All.PasswordMustChange.LowPart = PasswordMustChange.LowPart;
7005 InfoBuffer->All.PasswordMustChange.HighPart = PasswordMustChange.HighPart;
7006 }
7007
7008 /* Get the PasswordLastSet attribute */
7009 if (InfoBuffer->All.WhichFields & USER_ALL_PASSWORDLASTSET)
7010 {
7011 InfoBuffer->All.PasswordLastSet.LowPart = FixedData.PasswordLastSet.LowPart;
7012 InfoBuffer->All.PasswordLastSet.HighPart = FixedData.PasswordLastSet.HighPart;
7013 }
7014
7015 /* Get the AccountExpires attribute */
7016 if (InfoBuffer->All.WhichFields & USER_ALL_ACCOUNTEXPIRES)
7017 {
7018 InfoBuffer->All.AccountExpires.LowPart = FixedData.AccountExpires.LowPart;
7019 InfoBuffer->All.AccountExpires.HighPart = FixedData.AccountExpires.HighPart;
7020 }
7021
7022 /* Get the UserAccountControl attribute */
7023 if (InfoBuffer->All.WhichFields & USER_ALL_USERACCOUNTCONTROL)
7024 {
7025 InfoBuffer->All.UserAccountControl = FixedData.UserAccountControl;
7026 }
7027
7028 /* Get the Parameters attribute */
7029 if (InfoBuffer->All.WhichFields & USER_ALL_PARAMETERS)
7030 {
7031 Status = SampGetObjectAttributeString(UserObject,
7032 L"Parameters",
7033 &InfoBuffer->All.Parameters);
7034 if (!NT_SUCCESS(Status))
7035 {
7036 TRACE("Status 0x%08lx\n", Status);
7037 goto done;
7038 }
7039 }
7040
7041 /* Get the CountryCode attribute */
7042 if (InfoBuffer->All.WhichFields & USER_ALL_COUNTRYCODE)
7043 {
7044 InfoBuffer->All.CountryCode = FixedData.CountryCode;
7045 }
7046
7047 /* Get the CodePage attribute */
7048 if (InfoBuffer->All.WhichFields & USER_ALL_CODEPAGE)
7049 {
7050 InfoBuffer->All.CodePage = FixedData.CodePage;
7051 }
7052
7053 /* Get the LmPassword and NtPassword attributes */
7054 if (InfoBuffer->All.WhichFields & (USER_ALL_NTPASSWORDPRESENT | USER_ALL_LMPASSWORDPRESENT))
7055 {
7056 InfoBuffer->All.LmPasswordPresent = FALSE;
7057 InfoBuffer->All.NtPasswordPresent = FALSE;
7058
7059 /* Get the NT password */
7060 Length = 0;
7061 SampGetObjectAttribute(UserObject,
7062 L"NTPwd",
7063 NULL,
7064 NULL,
7065 &Length);
7066
7067 if (Length == sizeof(ENCRYPTED_NT_OWF_PASSWORD))
7068 {
7069 InfoBuffer->All.NtOwfPassword.Buffer = midl_user_allocate(sizeof(ENCRYPTED_NT_OWF_PASSWORD));
7070 if (InfoBuffer->All.NtOwfPassword.Buffer == NULL)
7071 {
7072 Status = STATUS_INSUFFICIENT_RESOURCES;
7073 goto done;
7074 }
7075
7076 InfoBuffer->All.NtOwfPassword.Length = sizeof(ENCRYPTED_NT_OWF_PASSWORD);
7077 InfoBuffer->All.NtOwfPassword.MaximumLength = sizeof(ENCRYPTED_NT_OWF_PASSWORD);
7078
7079 Status = SampGetObjectAttribute(UserObject,
7080 L"NTPwd",
7081 NULL,
7082 (PVOID)InfoBuffer->All.NtOwfPassword.Buffer,
7083 &Length);
7084 if (!NT_SUCCESS(Status))
7085 goto done;
7086
7087 if (memcmp(InfoBuffer->All.NtOwfPassword.Buffer,
7088 &EmptyNtHash,
7089 sizeof(ENCRYPTED_NT_OWF_PASSWORD)))
7090 InfoBuffer->All.NtPasswordPresent = TRUE;
7091 }
7092
7093 /* Get the LM password */
7094 Length = 0;
7095 SampGetObjectAttribute(UserObject,
7096 L"LMPwd",
7097 NULL,
7098 NULL,
7099 &Length);
7100
7101 if (Length == sizeof(ENCRYPTED_LM_OWF_PASSWORD))
7102 {
7103 InfoBuffer->All.LmOwfPassword.Buffer = midl_user_allocate(sizeof(ENCRYPTED_LM_OWF_PASSWORD));
7104 if (InfoBuffer->All.LmOwfPassword.Buffer == NULL)
7105 {
7106 Status = STATUS_INSUFFICIENT_RESOURCES;
7107 goto done;
7108 }
7109
7110 InfoBuffer->All.LmOwfPassword.Length = sizeof(ENCRYPTED_LM_OWF_PASSWORD);
7111 InfoBuffer->All.LmOwfPassword.MaximumLength = sizeof(ENCRYPTED_LM_OWF_PASSWORD);
7112
7113 Status = SampGetObjectAttribute(UserObject,
7114 L"LMPwd",
7115 NULL,
7116 (PVOID)InfoBuffer->All.LmOwfPassword.Buffer,
7117 &Length);
7118 if (!NT_SUCCESS(Status))
7119 goto done;
7120
7121 if (memcmp(InfoBuffer->All.LmOwfPassword.Buffer,
7122 &EmptyLmHash,
7123 sizeof(ENCRYPTED_LM_OWF_PASSWORD)))
7124 InfoBuffer->All.LmPasswordPresent = TRUE;
7125 }
7126 }
7127
7128 if (InfoBuffer->All.WhichFields & USER_ALL_PRIVATEDATA)
7129 {
7130 Status = SampGetObjectAttributeString(UserObject,
7131 L"PrivateData",
7132 &InfoBuffer->All.PrivateData);
7133 if (!NT_SUCCESS(Status))
7134 {
7135 TRACE("Status 0x%08lx\n", Status);
7136 goto done;
7137 }
7138 }
7139
7140 if (InfoBuffer->All.WhichFields & USER_ALL_PASSWORDEXPIRED)
7141 {
7142 /* FIXME */
7143 }
7144
7145 if (InfoBuffer->All.WhichFields & USER_ALL_SECURITYDESCRIPTOR)
7146 {
7147 Length = 0;
7148 SampGetObjectAttribute(UserObject,
7149 L"SecDesc",
7150 NULL,
7151 NULL,
7152 &Length);
7153
7154 if (Length > 0)
7155 {
7156 InfoBuffer->All.SecurityDescriptor.SecurityDescriptor = midl_user_allocate(Length);
7157 if (InfoBuffer->All.SecurityDescriptor.SecurityDescriptor == NULL)
7158 {
7159 Status = STATUS_INSUFFICIENT_RESOURCES;
7160 goto done;
7161 }
7162
7163 InfoBuffer->All.SecurityDescriptor.Length = Length;
7164
7165 Status = SampGetObjectAttribute(UserObject,
7166 L"SecDesc",
7167 NULL,
7168 (PVOID)InfoBuffer->All.SecurityDescriptor.SecurityDescriptor,
7169 &Length);
7170 if (!NT_SUCCESS(Status))
7171 goto done;
7172 }
7173 }
7174
7175 *Buffer = InfoBuffer;
7176
7177done:
7178 if (!NT_SUCCESS(Status))
7179 {
7180 if (InfoBuffer != NULL)
7181 {
7182 if (InfoBuffer->All.UserName.Buffer != NULL)
7183 midl_user_free(InfoBuffer->All.UserName.Buffer);
7184
7185 if (InfoBuffer->All.FullName.Buffer != NULL)
7186 midl_user_free(InfoBuffer->All.FullName.Buffer);
7187
7188 if (InfoBuffer->All.AdminComment.Buffer != NULL)
7189 midl_user_free(InfoBuffer->All.AdminComment.Buffer);
7190
7191 if (InfoBuffer->All.UserComment.Buffer != NULL)
7192 midl_user_free(InfoBuffer->All.UserComment.Buffer);
7193
7194 if (InfoBuffer->All.HomeDirectory.Buffer != NULL)
7195 midl_user_free(InfoBuffer->All.HomeDirectory.Buffer);
7196
7197 if (InfoBuffer->All.HomeDirectoryDrive.Buffer != NULL)
7198 midl_user_free(InfoBuffer->All.HomeDirectoryDrive.Buffer);
7199
7200 if (InfoBuffer->All.ScriptPath.Buffer != NULL)
7201 midl_user_free(InfoBuffer->All.ScriptPath.Buffer);
7202
7203 if (InfoBuffer->All.ProfilePath.Buffer != NULL)
7204 midl_user_free(InfoBuffer->All.ProfilePath.Buffer);
7205
7206 if (InfoBuffer->All.WorkStations.Buffer != NULL)
7207 midl_user_free(InfoBuffer->All.WorkStations.Buffer);
7208
7209 if (InfoBuffer->All.LogonHours.LogonHours != NULL)
7210 midl_user_free(InfoBuffer->All.LogonHours.LogonHours);
7211
7212 if (InfoBuffer->All.Parameters.Buffer != NULL)
7213 midl_user_free(InfoBuffer->All.Parameters.Buffer);
7214
7215 if (InfoBuffer->All.LmOwfPassword.Buffer != NULL)
7216 midl_user_free(InfoBuffer->All.LmOwfPassword.Buffer);
7217
7218 if (InfoBuffer->All.NtOwfPassword.Buffer != NULL)
7219 midl_user_free(InfoBuffer->All.NtOwfPassword.Buffer);
7220
7221 if (InfoBuffer->All.PrivateData.Buffer != NULL)
7222 midl_user_free(InfoBuffer->All.PrivateData.Buffer);
7223
7224 if (InfoBuffer->All.SecurityDescriptor.SecurityDescriptor != NULL)
7225 midl_user_free(InfoBuffer->All.SecurityDescriptor.SecurityDescriptor);
7226
7227 midl_user_free(InfoBuffer);
7228 }
7229 }
7230
7231 return Status;
7232}
7233
7234
7235/* Function 36 */
7236NTSTATUS
7237NTAPI
7238SamrQueryInformationUser(IN SAMPR_HANDLE UserHandle,
7239 IN USER_INFORMATION_CLASS UserInformationClass,
7240 OUT PSAMPR_USER_INFO_BUFFER *Buffer)
7241{
7242 TRACE("SamrQueryInformationUser(%p %lu %p)\n",
7243 UserHandle, UserInformationClass, Buffer);
7244
7245 return SamrQueryInformationUser2(UserHandle,
7246 UserInformationClass,
7247 Buffer);
7248}
7249
7250
7251static NTSTATUS
7252SampSetUserName(PSAM_DB_OBJECT UserObject,
7253 PRPC_UNICODE_STRING NewUserName)
7254{
7255 UNICODE_STRING OldUserName = {0, 0, NULL};
7256 NTSTATUS Status;
7257
7258 /* Check the account name */
7259 Status = SampCheckAccountName(NewUserName, 20);
7260 if (!NT_SUCCESS(Status))
7261 {
7262 TRACE("SampCheckAccountName failed (Status 0x%08lx)\n", Status);
7263 return Status;
7264 }
7265
7266 Status = SampGetObjectAttributeString(UserObject,
7267 L"Name",
7268 (PRPC_UNICODE_STRING)&OldUserName);
7269 if (!NT_SUCCESS(Status))
7270 {
7271 TRACE("SampGetObjectAttributeString failed (Status 0x%08lx)\n", Status);
7272 goto done;
7273 }
7274
7275 if (!RtlEqualUnicodeString(&OldUserName, (PCUNICODE_STRING)NewUserName, TRUE))
7276 {
7277 Status = SampCheckAccountNameInDomain(UserObject->ParentObject,
7278 NewUserName->Buffer);
7279 if (!NT_SUCCESS(Status))
7280 {
7281 TRACE("User name \'%S\' already exists in domain (Status 0x%08lx)\n",
7282 NewUserName->Buffer, Status);
7283 goto done;
7284 }
7285 }
7286
7287 Status = SampSetAccountNameInDomain(UserObject->ParentObject,
7288 L"Users",
7289 NewUserName->Buffer,
7290 UserObject->RelativeId);
7291 if (!NT_SUCCESS(Status))
7292 {
7293 TRACE("SampSetAccountNameInDomain failed (Status 0x%08lx)\n", Status);
7294 goto done;
7295 }
7296
7297 Status = SampRemoveAccountNameFromDomain(UserObject->ParentObject,
7298 L"Users",
7299 OldUserName.Buffer);
7300 if (!NT_SUCCESS(Status))
7301 {
7302 TRACE("SampRemoveAccountNameFromDomain failed (Status 0x%08lx)\n", Status);
7303 goto done;
7304 }
7305
7306 Status = SampSetObjectAttributeString(UserObject,
7307 L"Name",
7308 NewUserName);
7309 if (!NT_SUCCESS(Status))
7310 {
7311 TRACE("SampSetObjectAttribute failed (Status 0x%08lx)\n", Status);
7312 }
7313
7314done:
7315 if (OldUserName.Buffer != NULL)
7316 midl_user_free(OldUserName.Buffer);
7317
7318 return Status;
7319}
7320
7321
7322static NTSTATUS
7323SampSetUserGeneral(PSAM_DB_OBJECT UserObject,
7324 PSAMPR_USER_INFO_BUFFER Buffer)
7325{
7326 SAM_USER_FIXED_DATA FixedData;
7327 ULONG Length = 0;
7328 NTSTATUS Status;
7329
7330 Length = sizeof(SAM_USER_FIXED_DATA);
7331 Status = SampGetObjectAttribute(UserObject,
7332 L"F",
7333 NULL,
7334 (PVOID)&FixedData,
7335 &Length);
7336 if (!NT_SUCCESS(Status))
7337 goto done;
7338
7339 FixedData.PrimaryGroupId = Buffer->General.PrimaryGroupId;
7340
7341 Status = SampSetObjectAttribute(UserObject,
7342 L"F",
7343 REG_BINARY,
7344 &FixedData,
7345 Length);
7346 if (!NT_SUCCESS(Status))
7347 goto done;
7348
7349 Status = SampSetUserName(UserObject,
7350 &Buffer->General.UserName);
7351 if (!NT_SUCCESS(Status))
7352 goto done;
7353
7354 Status = SampSetObjectAttributeString(UserObject,
7355 L"FullName",
7356 &Buffer->General.FullName);
7357 if (!NT_SUCCESS(Status))
7358 goto done;
7359
7360 Status = SampSetObjectAttributeString(UserObject,
7361 L"AdminComment",
7362 &Buffer->General.AdminComment);
7363 if (!NT_SUCCESS(Status))
7364 goto done;
7365
7366 Status = SampSetObjectAttributeString(UserObject,
7367 L"UserComment",
7368 &Buffer->General.UserComment);
7369
7370done:
7371 return Status;
7372}
7373
7374
7375static NTSTATUS
7376SampSetUserPreferences(PSAM_DB_OBJECT UserObject,
7377 PSAMPR_USER_INFO_BUFFER Buffer)
7378{
7379 SAM_USER_FIXED_DATA FixedData;
7380 ULONG Length = 0;
7381 NTSTATUS Status;
7382
7383 Length = sizeof(SAM_USER_FIXED_DATA);
7384 Status = SampGetObjectAttribute(UserObject,
7385 L"F",
7386 NULL,
7387 (PVOID)&FixedData,
7388 &Length);
7389 if (!NT_SUCCESS(Status))
7390 goto done;
7391
7392 FixedData.CountryCode = Buffer->Preferences.CountryCode;
7393 FixedData.CodePage = Buffer->Preferences.CodePage;
7394
7395 Status = SampSetObjectAttribute(UserObject,
7396 L"F",
7397 REG_BINARY,
7398 &FixedData,
7399 Length);
7400 if (!NT_SUCCESS(Status))
7401 goto done;
7402
7403 Status = SampSetObjectAttributeString(UserObject,
7404 L"UserComment",
7405 &Buffer->Preferences.UserComment);
7406
7407done:
7408 return Status;
7409}
7410
7411
7412static NTSTATUS
7413SampSetUserPrimaryGroup(PSAM_DB_OBJECT UserObject,
7414 PSAMPR_USER_INFO_BUFFER Buffer)
7415{
7416 SAM_USER_FIXED_DATA FixedData;
7417 ULONG Length = 0;
7418 NTSTATUS Status;
7419
7420 Length = sizeof(SAM_USER_FIXED_DATA);
7421 Status = SampGetObjectAttribute(UserObject,
7422 L"F",
7423 NULL,
7424 (PVOID)&FixedData,
7425 &Length);
7426 if (!NT_SUCCESS(Status))
7427 goto done;
7428
7429 FixedData.PrimaryGroupId = Buffer->PrimaryGroup.PrimaryGroupId;
7430
7431 Status = SampSetObjectAttribute(UserObject,
7432 L"F",
7433 REG_BINARY,
7434 &FixedData,
7435 Length);
7436
7437done:
7438 return Status;
7439}
7440
7441
7442static NTSTATUS
7443SampSetUserControl(PSAM_DB_OBJECT UserObject,
7444 PSAMPR_USER_INFO_BUFFER Buffer)
7445{
7446 SAM_USER_FIXED_DATA FixedData;
7447 ULONG Length = 0;
7448 NTSTATUS Status;
7449
7450 Length = sizeof(SAM_USER_FIXED_DATA);
7451 Status = SampGetObjectAttribute(UserObject,
7452 L"F",
7453 NULL,
7454 (PVOID)&FixedData,
7455 &Length);
7456 if (!NT_SUCCESS(Status))
7457 goto done;
7458
7459 FixedData.UserAccountControl = Buffer->Control.UserAccountControl;
7460
7461 Status = SampSetObjectAttribute(UserObject,
7462 L"F",
7463 REG_BINARY,
7464 &FixedData,
7465 Length);
7466
7467done:
7468 return Status;
7469}
7470
7471
7472static NTSTATUS
7473SampSetUserExpires(PSAM_DB_OBJECT UserObject,
7474 PSAMPR_USER_INFO_BUFFER Buffer)
7475{
7476 SAM_USER_FIXED_DATA FixedData;
7477 ULONG Length = 0;
7478 NTSTATUS Status;
7479
7480 Length = sizeof(SAM_USER_FIXED_DATA);
7481 Status = SampGetObjectAttribute(UserObject,
7482 L"F",
7483 NULL,
7484 (PVOID)&FixedData,
7485 &Length);
7486 if (!NT_SUCCESS(Status))
7487 goto done;
7488
7489 FixedData.AccountExpires.LowPart = Buffer->Expires.AccountExpires.LowPart;
7490 FixedData.AccountExpires.HighPart = Buffer->Expires.AccountExpires.HighPart;
7491
7492 Status = SampSetObjectAttribute(UserObject,
7493 L"F",
7494 REG_BINARY,
7495 &FixedData,
7496 Length);
7497
7498done:
7499 return Status;
7500}
7501
7502
7503static NTSTATUS
7504SampSetUserInternal1(PSAM_DB_OBJECT UserObject,
7505 PSAMPR_USER_INFO_BUFFER Buffer)
7506{
7507 SAM_USER_FIXED_DATA FixedData;
7508 ULONG Length = 0;
7509 NTSTATUS Status = STATUS_SUCCESS;
7510
7511 /* FIXME: Decrypt NT password */
7512 /* FIXME: Decrypt LM password */
7513
7514 Status = SampSetUserPassword(UserObject,
7515 &Buffer->Internal1.EncryptedNtOwfPassword,
7516 Buffer->Internal1.NtPasswordPresent,
7517 &Buffer->Internal1.EncryptedLmOwfPassword,
7518 Buffer->Internal1.LmPasswordPresent);
7519 if (!NT_SUCCESS(Status))
7520 goto done;
7521
7522 /* Get the fixed user attributes */
7523 Length = sizeof(SAM_USER_FIXED_DATA);
7524 Status = SampGetObjectAttribute(UserObject,
7525 L"F",
7526 NULL,
7527 (PVOID)&FixedData,
7528 &Length);
7529 if (!NT_SUCCESS(Status))
7530 goto done;
7531
7532 if (Buffer->Internal1.PasswordExpired)
7533 {
7534 /* The password was last set ages ago */
7535 FixedData.PasswordLastSet.LowPart = 0;
7536 FixedData.PasswordLastSet.HighPart = 0;
7537 }
7538 else
7539 {
7540 /* The password was last set right now */
7541 Status = NtQuerySystemTime(&FixedData.PasswordLastSet);
7542 if (!NT_SUCCESS(Status))
7543 goto done;
7544 }
7545
7546 /* Set the fixed user attributes */
7547 Status = SampSetObjectAttribute(UserObject,
7548 L"F",
7549 REG_BINARY,
7550 &FixedData,
7551 Length);
7552
7553done:
7554 return Status;
7555}
7556
7557
7558static NTSTATUS
7559SampSetUserInternal2(PSAM_DB_OBJECT UserObject,
7560 PSAMPR_USER_INFO_BUFFER Buffer)
7561{
7562 SAM_USER_FIXED_DATA FixedData;
7563 ULONG Length = 0;
7564 NTSTATUS Status = STATUS_SUCCESS;
7565
7566 /* Get the fixed user attributes */
7567 Length = sizeof(SAM_USER_FIXED_DATA);
7568 Status = SampGetObjectAttribute(UserObject,
7569 L"F",
7570 NULL,
7571 (PVOID)&FixedData,
7572 &Length);
7573 if (!NT_SUCCESS(Status))
7574 goto done;
7575
7576 if ((Buffer->Internal2.Flags & USER_LOGON_SUCCESS) &&
7577 ((Buffer->Internal2.Flags & ~USER_LOGON_SUCCESS) == 0))
7578 {
7579 /* Update the LastLogon time */
7580 Status = NtQuerySystemTime(&FixedData.LastLogon);
7581 if (!NT_SUCCESS(Status))
7582 goto done;
7583
7584 FixedData.LogonCount++;
7585 FixedData.BadPasswordCount = 0;
7586 }
7587
7588 if ((Buffer->Internal2.Flags & USER_LOGON_BAD_PASSWORD) &&
7589 ((Buffer->Internal2.Flags & ~USER_LOGON_BAD_PASSWORD) == 0))
7590 {
7591 /* Update the LastBadPasswordTime */
7592 Status = NtQuerySystemTime(&FixedData.LastBadPasswordTime);
7593 if (!NT_SUCCESS(Status))
7594 goto done;
7595
7596 FixedData.BadPasswordCount++;
7597 }
7598
7599 /* Set the fixed user attributes */
7600 Status = SampSetObjectAttribute(UserObject,
7601 L"F",
7602 REG_BINARY,
7603 &FixedData,
7604 Length);
7605
7606done:
7607 return Status;
7608}
7609
7610
7611static NTSTATUS
7612SampSetUserAll(PSAM_DB_OBJECT UserObject,
7613 PSAMPR_USER_INFO_BUFFER Buffer)
7614{
7615 SAM_USER_FIXED_DATA FixedData;
7616 ULONG Length = 0;
7617 ULONG WhichFields;
7618 PENCRYPTED_NT_OWF_PASSWORD NtPassword = NULL;
7619 PENCRYPTED_LM_OWF_PASSWORD LmPassword = NULL;
7620 BOOLEAN NtPasswordPresent = FALSE;
7621 BOOLEAN LmPasswordPresent = FALSE;
7622 BOOLEAN WriteFixedData = FALSE;
7623 NTSTATUS Status = STATUS_SUCCESS;
7624
7625 WhichFields = Buffer->All.WhichFields;
7626
7627 /* Get the fixed size attributes */
7628 Length = sizeof(SAM_USER_FIXED_DATA);
7629 Status = SampGetObjectAttribute(UserObject,
7630 L"F",
7631 NULL,
7632 (PVOID)&FixedData,
7633 &Length);
7634 if (!NT_SUCCESS(Status))
7635 goto done;
7636
7637 if (WhichFields & USER_ALL_USERNAME)
7638 {
7639 Status = SampSetUserName(UserObject,
7640 &Buffer->All.UserName);
7641 if (!NT_SUCCESS(Status))
7642 goto done;
7643 }
7644
7645 if (WhichFields & USER_ALL_FULLNAME)
7646 {
7647 Status = SampSetObjectAttributeString(UserObject,
7648 L"FullName",
7649 &Buffer->All.FullName);
7650 if (!NT_SUCCESS(Status))
7651 goto done;
7652 }
7653
7654 if (WhichFields & USER_ALL_ADMINCOMMENT)
7655 {
7656 Status = SampSetObjectAttributeString(UserObject,
7657 L"AdminComment",
7658 &Buffer->All.AdminComment);
7659 if (!NT_SUCCESS(Status))
7660 goto done;
7661 }
7662
7663 if (WhichFields & USER_ALL_USERCOMMENT)
7664 {
7665 Status = SampSetObjectAttributeString(UserObject,
7666 L"UserComment",
7667 &Buffer->All.UserComment);
7668 if (!NT_SUCCESS(Status))
7669 goto done;
7670 }
7671
7672 if (WhichFields & USER_ALL_HOMEDIRECTORY)
7673 {
7674 Status = SampSetObjectAttributeString(UserObject,
7675 L"HomeDirectory",
7676 &Buffer->All.HomeDirectory);
7677 if (!NT_SUCCESS(Status))
7678 goto done;
7679 }
7680
7681 if (WhichFields & USER_ALL_HOMEDIRECTORYDRIVE)
7682 {
7683 Status = SampSetObjectAttributeString(UserObject,
7684 L"HomeDirectoryDrive",
7685 &Buffer->All.HomeDirectoryDrive);
7686 if (!NT_SUCCESS(Status))
7687 goto done;
7688 }
7689
7690 if (WhichFields & USER_ALL_SCRIPTPATH)
7691 {
7692 Status = SampSetObjectAttributeString(UserObject,
7693 L"ScriptPath",
7694 &Buffer->All.ScriptPath);
7695 if (!NT_SUCCESS(Status))
7696 goto done;
7697 }
7698
7699 if (WhichFields & USER_ALL_PROFILEPATH)
7700 {
7701 Status = SampSetObjectAttributeString(UserObject,
7702 L"ProfilePath",
7703 &Buffer->All.ProfilePath);
7704 if (!NT_SUCCESS(Status))
7705 goto done;
7706 }
7707
7708 if (WhichFields & USER_ALL_WORKSTATIONS)
7709 {
7710 Status = SampSetObjectAttributeString(UserObject,
7711 L"WorkStations",
7712 &Buffer->All.WorkStations);
7713 if (!NT_SUCCESS(Status))
7714 goto done;
7715 }
7716
7717 if (WhichFields & USER_ALL_PARAMETERS)
7718 {
7719 Status = SampSetObjectAttributeString(UserObject,
7720 L"Parameters",
7721 &Buffer->All.Parameters);
7722 if (!NT_SUCCESS(Status))
7723 goto done;
7724 }
7725
7726 if (WhichFields & USER_ALL_LOGONHOURS)
7727 {
7728 Status = SampSetLogonHoursAttribute(UserObject,
7729 &Buffer->All.LogonHours);
7730 if (!NT_SUCCESS(Status))
7731 goto done;
7732 }
7733
7734 if (WhichFields & USER_ALL_PRIMARYGROUPID)
7735 {
7736 FixedData.PrimaryGroupId = Buffer->All.PrimaryGroupId;
7737 WriteFixedData = TRUE;
7738 }
7739
7740 if (WhichFields & USER_ALL_ACCOUNTEXPIRES)
7741 {
7742 FixedData.AccountExpires.LowPart = Buffer->All.AccountExpires.LowPart;
7743 FixedData.AccountExpires.HighPart = Buffer->All.AccountExpires.HighPart;
7744 WriteFixedData = TRUE;
7745 }
7746
7747 if (WhichFields & USER_ALL_USERACCOUNTCONTROL)
7748 {
7749 FixedData.UserAccountControl = Buffer->All.UserAccountControl;
7750 WriteFixedData = TRUE;
7751 }
7752
7753 if (WhichFields & USER_ALL_COUNTRYCODE)
7754 {
7755 FixedData.CountryCode = Buffer->All.CountryCode;
7756 WriteFixedData = TRUE;
7757 }
7758
7759 if (WhichFields & USER_ALL_CODEPAGE)
7760 {
7761 FixedData.CodePage = Buffer->All.CodePage;
7762 WriteFixedData = TRUE;
7763 }
7764
7765 if (WhichFields & (USER_ALL_NTPASSWORDPRESENT |
7766 USER_ALL_LMPASSWORDPRESENT))
7767 {
7768 if (WhichFields & USER_ALL_NTPASSWORDPRESENT)
7769 {
7770 NtPassword = (PENCRYPTED_NT_OWF_PASSWORD)Buffer->All.NtOwfPassword.Buffer;
7771 NtPasswordPresent = Buffer->All.NtPasswordPresent;
7772 }
7773
7774 if (WhichFields & USER_ALL_LMPASSWORDPRESENT)
7775 {
7776 LmPassword = (PENCRYPTED_LM_OWF_PASSWORD)Buffer->All.LmOwfPassword.Buffer;
7777 LmPasswordPresent = Buffer->All.LmPasswordPresent;
7778 }
7779
7780 Status = SampSetUserPassword(UserObject,
7781 NtPassword,
7782 NtPasswordPresent,
7783 LmPassword,
7784 LmPasswordPresent);
7785 if (!NT_SUCCESS(Status))
7786 goto done;
7787
7788 /* The password has just been set */
7789 Status = NtQuerySystemTime(&FixedData.PasswordLastSet);
7790 if (!NT_SUCCESS(Status))
7791 goto done;
7792
7793 WriteFixedData = TRUE;
7794 }
7795
7796 if (WhichFields & USER_ALL_PRIVATEDATA)
7797 {
7798 Status = SampSetObjectAttributeString(UserObject,
7799 L"PrivateData",
7800 &Buffer->All.PrivateData);
7801 if (!NT_SUCCESS(Status))
7802 goto done;
7803 }
7804
7805 if (WhichFields & USER_ALL_PASSWORDEXPIRED)
7806 {
7807 if (Buffer->All.PasswordExpired)
7808 {
7809 /* The password was last set ages ago */
7810 FixedData.PasswordLastSet.LowPart = 0;
7811 FixedData.PasswordLastSet.HighPart = 0;
7812 }
7813 else
7814 {
7815 /* The password was last set right now */
7816 Status = NtQuerySystemTime(&FixedData.PasswordLastSet);
7817 if (!NT_SUCCESS(Status))
7818 goto done;
7819 }
7820
7821 WriteFixedData = TRUE;
7822 }
7823
7824 if (WhichFields & USER_ALL_SECURITYDESCRIPTOR)
7825 {
7826 Status = SampSetObjectAttribute(UserObject,
7827 L"SecDesc",
7828 REG_BINARY,
7829 Buffer->All.SecurityDescriptor.SecurityDescriptor,
7830 Buffer->All.SecurityDescriptor.Length);
7831 }
7832
7833 if (WriteFixedData != FALSE)
7834 {
7835 Status = SampSetObjectAttribute(UserObject,
7836 L"F",
7837 REG_BINARY,
7838 &FixedData,
7839 Length);
7840 if (!NT_SUCCESS(Status))
7841 goto done;
7842 }
7843
7844done:
7845 return Status;
7846}
7847
7848
7849/* Function 37 */
7850NTSTATUS
7851NTAPI
7852SamrSetInformationUser(IN SAMPR_HANDLE UserHandle,
7853 IN USER_INFORMATION_CLASS UserInformationClass,
7854 IN PSAMPR_USER_INFO_BUFFER Buffer)
7855{
7856 TRACE("SamrSetInformationUser(%p %lu %p)\n",
7857 UserHandle, UserInformationClass, Buffer);
7858
7859 return SamrSetInformationUser2(UserHandle,
7860 UserInformationClass,
7861 Buffer);
7862}
7863
7864
7865/* Function 38 */
7866NTSTATUS
7867NTAPI
7868SamrChangePasswordUser(IN SAMPR_HANDLE UserHandle,
7869 IN unsigned char LmPresent,
7870 IN PENCRYPTED_LM_OWF_PASSWORD OldLmEncryptedWithNewLm,
7871 IN PENCRYPTED_LM_OWF_PASSWORD NewLmEncryptedWithOldLm,
7872 IN unsigned char NtPresent,
7873 IN PENCRYPTED_NT_OWF_PASSWORD OldNtEncryptedWithNewNt,
7874 IN PENCRYPTED_NT_OWF_PASSWORD NewNtEncryptedWithOldNt,
7875 IN unsigned char NtCrossEncryptionPresent,
7876 IN PENCRYPTED_NT_OWF_PASSWORD NewNtEncryptedWithNewLm,
7877 IN unsigned char LmCrossEncryptionPresent,
7878 IN PENCRYPTED_LM_OWF_PASSWORD NewLmEncryptedWithNewNt)
7879{
7880 ENCRYPTED_LM_OWF_PASSWORD StoredLmPassword;
7881 ENCRYPTED_NT_OWF_PASSWORD StoredNtPassword;
7882 LM_OWF_PASSWORD OldLmPassword;
7883 LM_OWF_PASSWORD NewLmPassword;
7884 NT_OWF_PASSWORD OldNtPassword;
7885 NT_OWF_PASSWORD NewNtPassword;
7886 BOOLEAN StoredLmPresent = FALSE;
7887 BOOLEAN StoredNtPresent = FALSE;
7888 BOOLEAN StoredLmEmpty = TRUE;
7889 BOOLEAN StoredNtEmpty = TRUE;
7890 PSAM_DB_OBJECT UserObject;
7891 ULONG Length;
7892 SAM_USER_FIXED_DATA UserFixedData;
7893 SAM_DOMAIN_FIXED_DATA DomainFixedData;
7894 LARGE_INTEGER SystemTime;
7895 NTSTATUS Status;
7896
7897 DBG_UNREFERENCED_LOCAL_VARIABLE(StoredLmPresent);
7898 DBG_UNREFERENCED_LOCAL_VARIABLE(StoredNtPresent);
7899 DBG_UNREFERENCED_LOCAL_VARIABLE(StoredLmEmpty);
7900
7901 TRACE("SamrChangePasswordUser(%p %u %p %p %u %p %p %u %p %u %p)\n",
7902 UserHandle, LmPresent, OldLmEncryptedWithNewLm, NewLmEncryptedWithOldLm,
7903 NtPresent, OldNtEncryptedWithNewNt, NewNtEncryptedWithOldNt, NtCrossEncryptionPresent,
7904 NewNtEncryptedWithNewLm, LmCrossEncryptionPresent, NewLmEncryptedWithNewNt);
7905
7906 RtlAcquireResourceExclusive(&SampResource,
7907 TRUE);
7908
7909 /* Validate the user handle */
7910 Status = SampValidateDbObject(UserHandle,
7911 SamDbUserObject,
7912 USER_CHANGE_PASSWORD,
7913 &UserObject);
7914 if (!NT_SUCCESS(Status))
7915 {
7916 TRACE("SampValidateDbObject failed with status 0x%08lx\n", Status);
7917 goto done;
7918 }
7919
7920 /* Get the current time */
7921 Status = NtQuerySystemTime(&SystemTime);
7922 if (!NT_SUCCESS(Status))
7923 {
7924 TRACE("NtQuerySystemTime failed (Status 0x%08lx)\n", Status);
7925 goto done;
7926 }
7927
7928 /* Retrieve the LM password */
7929 Length = sizeof(ENCRYPTED_LM_OWF_PASSWORD);
7930 Status = SampGetObjectAttribute(UserObject,
7931 L"LMPwd",
7932 NULL,
7933 &StoredLmPassword,
7934 &Length);
7935 if (NT_SUCCESS(Status))
7936 {
7937 if (Length == sizeof(ENCRYPTED_LM_OWF_PASSWORD))
7938 {
7939 StoredLmPresent = TRUE;
7940 if (!RtlEqualMemory(&StoredLmPassword,
7941 &EmptyLmHash,
7942 sizeof(ENCRYPTED_LM_OWF_PASSWORD)))
7943 StoredLmEmpty = FALSE;
7944 }
7945 }
7946
7947 /* Retrieve the NT password */
7948 Length = sizeof(ENCRYPTED_NT_OWF_PASSWORD);
7949 Status = SampGetObjectAttribute(UserObject,
7950 L"NTPwd",
7951 NULL,
7952 &StoredNtPassword,
7953 &Length);
7954 if (NT_SUCCESS(Status))
7955 {
7956 if (Length == sizeof(ENCRYPTED_NT_OWF_PASSWORD))
7957 {
7958 StoredNtPresent = TRUE;
7959 if (!RtlEqualMemory(&StoredNtPassword,
7960 &EmptyNtHash,
7961 sizeof(ENCRYPTED_NT_OWF_PASSWORD)))
7962 StoredNtEmpty = FALSE;
7963 }
7964 }
7965
7966 /* Retrieve the fixed size user data */
7967 Length = sizeof(SAM_USER_FIXED_DATA);
7968 Status = SampGetObjectAttribute(UserObject,
7969 L"F",
7970 NULL,
7971 &UserFixedData,
7972 &Length);
7973 if (!NT_SUCCESS(Status))
7974 {
7975 TRACE("SampGetObjectAttribute failed to retrieve the fixed user data (Status 0x%08lx)\n", Status);
7976 goto done;
7977 }
7978
7979 /* Check if we can change the password at this time */
7980 if ((StoredLmEmpty == FALSE) || (StoredNtEmpty == FALSE))
7981 {
7982 /* Get fixed domain data */
7983 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
7984 Status = SampGetObjectAttribute(UserObject->ParentObject,
7985 L"F",
7986 NULL,
7987 &DomainFixedData,
7988 &Length);
7989 if (!NT_SUCCESS(Status))
7990 {
7991 TRACE("SampGetObjectAttribute failed to retrieve the fixed domain data (Status 0x%08lx)\n", Status);
7992 goto done;
7993 }
7994
7995 if (DomainFixedData.MinPasswordAge.QuadPart > 0)
7996 {
7997 if (SystemTime.QuadPart < (UserFixedData.PasswordLastSet.QuadPart + DomainFixedData.MinPasswordAge.QuadPart))
7998 {
7999 Status = STATUS_ACCOUNT_RESTRICTION;
8000 goto done;
8001 }
8002 }
8003 }
8004
8005 /* Decrypt the LM passwords, if present */
8006 if (LmPresent)
8007 {
8008 Status = SystemFunction013((const BYTE *)NewLmEncryptedWithOldLm,
8009 (const BYTE *)&StoredLmPassword,
8010 (LPBYTE)&NewLmPassword);
8011 if (!NT_SUCCESS(Status))
8012 {
8013 TRACE("SystemFunction013 failed (Status 0x%08lx)\n", Status);
8014 goto done;
8015 }
8016
8017 Status = SystemFunction013((const BYTE *)OldLmEncryptedWithNewLm,
8018 (const BYTE *)&NewLmPassword,
8019 (LPBYTE)&OldLmPassword);
8020 if (!NT_SUCCESS(Status))
8021 {
8022 TRACE("SystemFunction013 failed (Status 0x%08lx)\n", Status);
8023 goto done;
8024 }
8025 }
8026
8027 /* Decrypt the NT passwords, if present */
8028 if (NtPresent)
8029 {
8030 Status = SystemFunction013((const BYTE *)NewNtEncryptedWithOldNt,
8031 (const BYTE *)&StoredNtPassword,
8032 (LPBYTE)&NewNtPassword);
8033 if (!NT_SUCCESS(Status))
8034 {
8035 TRACE("SystemFunction013 failed (Status 0x%08lx)\n", Status);
8036 goto done;
8037 }
8038
8039 Status = SystemFunction013((const BYTE *)OldNtEncryptedWithNewNt,
8040 (const BYTE *)&NewNtPassword,
8041 (LPBYTE)&OldNtPassword);
8042 if (!NT_SUCCESS(Status))
8043 {
8044 TRACE("SystemFunction013 failed (Status 0x%08lx)\n", Status);
8045 goto done;
8046 }
8047 }
8048
8049 /* Check if the old passwords match the stored ones */
8050 if (NtPresent)
8051 {
8052 if (LmPresent)
8053 {
8054 if (!RtlEqualMemory(&StoredLmPassword,
8055 &OldLmPassword,
8056 sizeof(ENCRYPTED_LM_OWF_PASSWORD)))
8057 {
8058 TRACE("Old LM Password does not match!\n");
8059 Status = STATUS_WRONG_PASSWORD;
8060 }
8061 else
8062 {
8063 if (!RtlEqualMemory(&StoredNtPassword,
8064 &OldNtPassword,
8065 sizeof(ENCRYPTED_LM_OWF_PASSWORD)))
8066 {
8067 TRACE("Old NT Password does not match!\n");
8068 Status = STATUS_WRONG_PASSWORD;
8069 }
8070 }
8071 }
8072 else
8073 {
8074 if (!RtlEqualMemory(&StoredNtPassword,
8075 &OldNtPassword,
8076 sizeof(ENCRYPTED_LM_OWF_PASSWORD)))
8077 {
8078 TRACE("Old NT Password does not match!\n");
8079 Status = STATUS_WRONG_PASSWORD;
8080 }
8081 }
8082 }
8083 else
8084 {
8085 if (LmPresent)
8086 {
8087 if (!RtlEqualMemory(&StoredLmPassword,
8088 &OldLmPassword,
8089 sizeof(ENCRYPTED_LM_OWF_PASSWORD)))
8090 {
8091 TRACE("Old LM Password does not match!\n");
8092 Status = STATUS_WRONG_PASSWORD;
8093 }
8094 }
8095 else
8096 {
8097 Status = STATUS_INVALID_PARAMETER;
8098 }
8099 }
8100
8101 /* Store the new password hashes */
8102 if (NT_SUCCESS(Status))
8103 {
8104 Status = SampSetUserPassword(UserObject,
8105 &NewNtPassword,
8106 NtPresent,
8107 &NewLmPassword,
8108 LmPresent);
8109 if (NT_SUCCESS(Status))
8110 {
8111 /* Update PasswordLastSet */
8112 UserFixedData.PasswordLastSet.QuadPart = SystemTime.QuadPart;
8113
8114 /* Set the fixed size user data */
8115 Length = sizeof(SAM_USER_FIXED_DATA);
8116 Status = SampSetObjectAttribute(UserObject,
8117 L"F",
8118 REG_BINARY,
8119 &UserFixedData,
8120 Length);
8121 }
8122 }
8123
8124 if (Status == STATUS_WRONG_PASSWORD)
8125 {
8126 /* Update BadPasswordCount and LastBadPasswordTime */
8127 UserFixedData.BadPasswordCount++;
8128 UserFixedData.LastBadPasswordTime.QuadPart = SystemTime.QuadPart;
8129
8130 /* Set the fixed size user data */
8131 Length = sizeof(SAM_USER_FIXED_DATA);
8132 Status = SampSetObjectAttribute(UserObject,
8133 L"F",
8134 REG_BINARY,
8135 &UserFixedData,
8136 Length);
8137 }
8138
8139done:
8140 RtlReleaseResource(&SampResource);
8141
8142 return Status;
8143}
8144
8145
8146/* Function 39 */
8147NTSTATUS
8148NTAPI
8149SamrGetGroupsForUser(IN SAMPR_HANDLE UserHandle,
8150 OUT PSAMPR_GET_GROUPS_BUFFER *Groups)
8151{
8152 PSAMPR_GET_GROUPS_BUFFER GroupsBuffer = NULL;
8153 PSAM_DB_OBJECT UserObject;
8154 ULONG Length = 0;
8155 NTSTATUS Status;
8156
8157 TRACE("SamrGetGroupsForUser(%p %p)\n",
8158 UserHandle, Groups);
8159
8160 RtlAcquireResourceShared(&SampResource,
8161 TRUE);
8162
8163 /* Validate the user handle */
8164 Status = SampValidateDbObject(UserHandle,
8165 SamDbUserObject,
8166 USER_LIST_GROUPS,
8167 &UserObject);
8168 if (!NT_SUCCESS(Status))
8169 {
8170 TRACE("SampValidateDbObject failed with status 0x%08lx\n", Status);
8171 goto done;
8172 }
8173
8174 /* Allocate the groups buffer */
8175 GroupsBuffer = midl_user_allocate(sizeof(SAMPR_GET_GROUPS_BUFFER));
8176 if (GroupsBuffer == NULL)
8177 {
8178 Status = STATUS_INSUFFICIENT_RESOURCES;
8179 goto done;
8180 }
8181
8182 /*
8183 * Get the size of the Groups attribute.
8184 * Do not check the status code because in case of an error
8185 * Length will be 0. And that is all we need.
8186 */
8187 SampGetObjectAttribute(UserObject,
8188 L"Groups",
8189 NULL,
8190 NULL,
8191 &Length);
8192
8193 /* If there is no Groups attribute, return a groups buffer without an array */
8194 if (Length == 0)
8195 {
8196 GroupsBuffer->MembershipCount = 0;
8197 GroupsBuffer->Groups = NULL;
8198
8199 *Groups = GroupsBuffer;
8200
8201 Status = STATUS_SUCCESS;
8202 goto done;
8203 }
8204
8205 /* Allocate a buffer for the Groups attribute */
8206 GroupsBuffer->Groups = midl_user_allocate(Length);
8207 if (GroupsBuffer->Groups == NULL)
8208 {
8209 Status = STATUS_INSUFFICIENT_RESOURCES;
8210 goto done;
8211 }
8212
8213 /* Retrieve the Grous attribute */
8214 Status = SampGetObjectAttribute(UserObject,
8215 L"Groups",
8216 NULL,
8217 GroupsBuffer->Groups,
8218 &Length);
8219 if (!NT_SUCCESS(Status))
8220 {
8221 TRACE("SampGetObjectAttribute failed with status 0x%08lx\n", Status);
8222 goto done;
8223 }
8224
8225 /* Calculate the membership count */
8226 GroupsBuffer->MembershipCount = Length / sizeof(GROUP_MEMBERSHIP);
8227
8228 /* Return the groups buffer to the caller */
8229 *Groups = GroupsBuffer;
8230
8231done:
8232 if (!NT_SUCCESS(Status))
8233 {
8234 if (GroupsBuffer != NULL)
8235 {
8236 if (GroupsBuffer->Groups != NULL)
8237 midl_user_free(GroupsBuffer->Groups);
8238
8239 midl_user_free(GroupsBuffer);
8240 }
8241 }
8242
8243 RtlReleaseResource(&SampResource);
8244
8245 return Status;
8246}
8247
8248
8249/* Function 40 */
8250NTSTATUS
8251NTAPI
8252SamrQueryDisplayInformation(IN SAMPR_HANDLE DomainHandle,
8253 IN DOMAIN_DISPLAY_INFORMATION DisplayInformationClass,
8254 IN unsigned long Index,
8255 IN unsigned long EntryCount,
8256 IN unsigned long PreferredMaximumLength,
8257 OUT unsigned long *TotalAvailable,
8258 OUT unsigned long *TotalReturned,
8259 OUT PSAMPR_DISPLAY_INFO_BUFFER Buffer)
8260{
8261 TRACE("SamrQueryDisplayInformation(%p %lu %lu %lu %lu %p %p %p)\n",
8262 DomainHandle, DisplayInformationClass, Index,
8263 EntryCount, PreferredMaximumLength, TotalAvailable,
8264 TotalReturned, Buffer);
8265
8266 return SamrQueryDisplayInformation3(DomainHandle,
8267 DisplayInformationClass,
8268 Index,
8269 EntryCount,
8270 PreferredMaximumLength,
8271 TotalAvailable,
8272 TotalReturned,
8273 Buffer);
8274}
8275
8276
8277/* Function 41 */
8278NTSTATUS
8279NTAPI
8280SamrGetDisplayEnumerationIndex(IN SAMPR_HANDLE DomainHandle,
8281 IN DOMAIN_DISPLAY_INFORMATION DisplayInformationClass,
8282 IN PRPC_UNICODE_STRING Prefix,
8283 OUT unsigned long *Index)
8284{
8285 TRACE("SamrGetDisplayEnumerationIndex(%p %lu %p %p)\n",
8286 DomainHandle, DisplayInformationClass, Prefix, Index);
8287
8288 return SamrGetDisplayEnumerationIndex2(DomainHandle,
8289 DisplayInformationClass,
8290 Prefix,
8291 Index);
8292}
8293
8294
8295/* Function 42 */
8296NTSTATUS
8297NTAPI
8298SamrTestPrivateFunctionsDomain(IN SAMPR_HANDLE DomainHandle)
8299{
8300 UNIMPLEMENTED;
8301 return STATUS_NOT_IMPLEMENTED;
8302}
8303
8304
8305/* Function 43 */
8306NTSTATUS
8307NTAPI
8308SamrTestPrivateFunctionsUser(IN SAMPR_HANDLE UserHandle)
8309{
8310 UNIMPLEMENTED;
8311 return STATUS_NOT_IMPLEMENTED;
8312}
8313
8314
8315/* Function 44 */
8316NTSTATUS
8317NTAPI
8318SamrGetUserDomainPasswordInformation(IN SAMPR_HANDLE UserHandle,
8319 OUT PUSER_DOMAIN_PASSWORD_INFORMATION PasswordInformation)
8320{
8321 SAM_DOMAIN_FIXED_DATA DomainFixedData;
8322 SAM_USER_FIXED_DATA UserFixedData;
8323 PSAM_DB_OBJECT DomainObject;
8324 PSAM_DB_OBJECT UserObject;
8325 ULONG Length = 0;
8326 NTSTATUS Status;
8327
8328 TRACE("SamrGetUserDomainPasswordInformation(%p %p)\n",
8329 UserHandle, PasswordInformation);
8330
8331 RtlAcquireResourceShared(&SampResource,
8332 TRUE);
8333
8334 /* Validate the user handle */
8335 Status = SampValidateDbObject(UserHandle,
8336 SamDbUserObject,
8337 0,
8338 &UserObject);
8339 if (!NT_SUCCESS(Status))
8340 {
8341 TRACE("SampValidateDbObject failed with status 0x%08lx\n", Status);
8342 goto done;
8343 }
8344
8345 /* Validate the domain object */
8346 Status = SampValidateDbObject((SAMPR_HANDLE)UserObject->ParentObject,
8347 SamDbDomainObject,
8348 DOMAIN_READ_PASSWORD_PARAMETERS,
8349 &DomainObject);
8350 if (!NT_SUCCESS(Status))
8351 {
8352 TRACE("SampValidateDbObject failed with status 0x%08lx\n", Status);
8353 goto done;
8354 }
8355
8356 /* Get fixed user data */
8357 Length = sizeof(SAM_USER_FIXED_DATA);
8358 Status = SampGetObjectAttribute(UserObject,
8359 L"F",
8360 NULL,
8361 (PVOID)&UserFixedData,
8362 &Length);
8363 if (!NT_SUCCESS(Status))
8364 {
8365 TRACE("SampGetObjectAttribute failed with status 0x%08lx\n", Status);
8366 goto done;
8367 }
8368
8369 if ((UserObject->RelativeId == DOMAIN_USER_RID_KRBTGT) ||
8370 (UserFixedData.UserAccountControl & (USER_INTERDOMAIN_TRUST_ACCOUNT |
8371 USER_WORKSTATION_TRUST_ACCOUNT |
8372 USER_SERVER_TRUST_ACCOUNT)))
8373 {
8374 PasswordInformation->MinPasswordLength = 0;
8375 PasswordInformation->PasswordProperties = 0;
8376 }
8377 else
8378 {
8379 /* Get fixed domain data */
8380 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
8381 Status = SampGetObjectAttribute(DomainObject,
8382 L"F",
8383 NULL,
8384 (PVOID)&DomainFixedData,
8385 &Length);
8386 if (!NT_SUCCESS(Status))
8387 {
8388 TRACE("SampGetObjectAttribute failed with status 0x%08lx\n", Status);
8389 goto done;
8390 }
8391
8392 PasswordInformation->MinPasswordLength = DomainFixedData.MinPasswordLength;
8393 PasswordInformation->PasswordProperties = DomainFixedData.PasswordProperties;
8394 }
8395
8396done:
8397 RtlReleaseResource(&SampResource);
8398
8399 return STATUS_SUCCESS;
8400}
8401
8402
8403/* Function 45 */
8404NTSTATUS
8405NTAPI
8406SamrRemoveMemberFromForeignDomain(IN SAMPR_HANDLE DomainHandle,
8407 IN PRPC_SID MemberSid)
8408{
8409 PSAM_DB_OBJECT DomainObject;
8410 ULONG Rid = 0;
8411 NTSTATUS Status;
8412
8413 TRACE("SamrRemoveMemberFromForeignDomain(%p %p)\n",
8414 DomainHandle, MemberSid);
8415
8416 RtlAcquireResourceExclusive(&SampResource,
8417 TRUE);
8418
8419 /* Validate the domain object */
8420 Status = SampValidateDbObject(DomainHandle,
8421 SamDbDomainObject,
8422 DOMAIN_LOOKUP,
8423 &DomainObject);
8424 if (!NT_SUCCESS(Status))
8425 {
8426 TRACE("SampValidateDbObject failed with status 0x%08lx\n", Status);
8427 goto done;
8428 }
8429
8430 /* Retrieve the RID from the MemberSID */
8431 Status = SampGetRidFromSid((PSID)MemberSid,
8432 &Rid);
8433 if (!NT_SUCCESS(Status))
8434 {
8435 TRACE("SampGetRidFromSid failed with status 0x%08lx\n", Status);
8436 goto done;
8437 }
8438
8439 /* Fail, if the RID represents a special account */
8440 if (Rid < 1000)
8441 {
8442 TRACE("Cannot remove a special account (RID: %lu)\n", Rid);
8443 Status = STATUS_SPECIAL_ACCOUNT;
8444 goto done;
8445 }
8446
8447 /* Remove the member from all aliases in the domain */
8448 Status = SampRemoveMemberFromAllAliases(DomainObject,
8449 MemberSid);
8450 if (!NT_SUCCESS(Status))
8451 {
8452 TRACE("SampRemoveMemberFromAllAliases failed with status 0x%08lx\n", Status);
8453 }
8454
8455done:
8456 RtlReleaseResource(&SampResource);
8457
8458 return Status;
8459}
8460
8461
8462/* Function 46 */
8463NTSTATUS
8464NTAPI
8465SamrQueryInformationDomain2(IN SAMPR_HANDLE DomainHandle,
8466 IN DOMAIN_INFORMATION_CLASS DomainInformationClass,
8467 OUT PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
8468{
8469 PSAM_DB_OBJECT DomainObject;
8470 ACCESS_MASK DesiredAccess;
8471 NTSTATUS Status;
8472
8473 TRACE("SamrQueryInformationDomain2(%p %lu %p)\n",
8474 DomainHandle, DomainInformationClass, Buffer);
8475
8476 switch (DomainInformationClass)
8477 {
8478 case DomainPasswordInformation:
8479 case DomainLockoutInformation:
8480 DesiredAccess = DOMAIN_READ_PASSWORD_PARAMETERS;
8481 break;
8482
8483 case DomainGeneralInformation:
8484 case DomainLogoffInformation:
8485 case DomainOemInformation:
8486 case DomainNameInformation:
8487 case DomainReplicationInformation:
8488 case DomainServerRoleInformation:
8489 case DomainModifiedInformation:
8490 case DomainStateInformation:
8491 case DomainModifiedInformation2:
8492 DesiredAccess = DOMAIN_READ_OTHER_PARAMETERS;
8493 break;
8494
8495 case DomainGeneralInformation2:
8496 DesiredAccess = DOMAIN_READ_PASSWORD_PARAMETERS |
8497 DOMAIN_READ_OTHER_PARAMETERS;
8498 break;
8499
8500 default:
8501 return STATUS_INVALID_INFO_CLASS;
8502 }
8503
8504 RtlAcquireResourceShared(&SampResource,
8505 TRUE);
8506
8507 /* Validate the server handle */
8508 Status = SampValidateDbObject(DomainHandle,
8509 SamDbDomainObject,
8510 DesiredAccess,
8511 &DomainObject);
8512 if (!NT_SUCCESS(Status))
8513 goto done;
8514
8515 switch (DomainInformationClass)
8516 {
8517 case DomainPasswordInformation:
8518 Status = SampQueryDomainPassword(DomainObject,
8519 Buffer);
8520 break;
8521
8522 case DomainGeneralInformation:
8523 Status = SampQueryDomainGeneral(DomainObject,
8524 Buffer);
8525 break;
8526
8527 case DomainLogoffInformation:
8528 Status = SampQueryDomainLogoff(DomainObject,
8529 Buffer);
8530 break;
8531
8532 case DomainOemInformation:
8533 Status = SampQueryDomainOem(DomainObject,
8534 Buffer);
8535 break;
8536
8537 case DomainNameInformation:
8538 Status = SampQueryDomainName(DomainObject,
8539 Buffer);
8540 break;
8541
8542 case DomainReplicationInformation:
8543 Status = SampQueryDomainReplication(DomainObject,
8544 Buffer);
8545 break;
8546
8547 case DomainServerRoleInformation:
8548 Status = SampQueryDomainServerRole(DomainObject,
8549 Buffer);
8550 break;
8551
8552 case DomainModifiedInformation:
8553 Status = SampQueryDomainModified(DomainObject,
8554 Buffer);
8555 break;
8556
8557 case DomainStateInformation:
8558 Status = SampQueryDomainState(DomainObject,
8559 Buffer);
8560 break;
8561
8562 case DomainGeneralInformation2:
8563 Status = SampQueryDomainGeneral2(DomainObject,
8564 Buffer);
8565 break;
8566
8567 case DomainLockoutInformation:
8568 Status = SampQueryDomainLockout(DomainObject,
8569 Buffer);
8570 break;
8571
8572 case DomainModifiedInformation2:
8573 Status = SampQueryDomainModified2(DomainObject,
8574 Buffer);
8575 break;
8576
8577 default:
8578 Status = STATUS_NOT_IMPLEMENTED;
8579 }
8580
8581done:
8582 RtlReleaseResource(&SampResource);
8583
8584 return Status;
8585}
8586
8587
8588/* Function 47 */
8589NTSTATUS
8590NTAPI
8591SamrQueryInformationUser2(IN SAMPR_HANDLE UserHandle,
8592 IN USER_INFORMATION_CLASS UserInformationClass,
8593 OUT PSAMPR_USER_INFO_BUFFER *Buffer)
8594{
8595 PSAM_DB_OBJECT UserObject;
8596 ACCESS_MASK DesiredAccess;
8597 NTSTATUS Status;
8598
8599 TRACE("SamrQueryInformationUser2(%p %lu %p)\n",
8600 UserHandle, UserInformationClass, Buffer);
8601
8602 switch (UserInformationClass)
8603 {
8604 case UserGeneralInformation:
8605 case UserNameInformation:
8606 case UserAccountNameInformation:
8607 case UserFullNameInformation:
8608 case UserPrimaryGroupInformation:
8609 case UserAdminCommentInformation:
8610 DesiredAccess = USER_READ_GENERAL;
8611 break;
8612
8613 case UserLogonHoursInformation:
8614 case UserHomeInformation:
8615 case UserScriptInformation:
8616 case UserProfileInformation:
8617 case UserWorkStationsInformation:
8618 DesiredAccess = USER_READ_LOGON;
8619 break;
8620
8621 case UserControlInformation:
8622 case UserExpiresInformation:
8623 case UserParametersInformation:
8624 DesiredAccess = USER_READ_ACCOUNT;
8625 break;
8626
8627 case UserPreferencesInformation:
8628 DesiredAccess = USER_READ_GENERAL |
8629 USER_READ_PREFERENCES;
8630 break;
8631
8632 case UserLogonInformation:
8633 case UserAccountInformation:
8634 DesiredAccess = USER_READ_GENERAL |
8635 USER_READ_PREFERENCES |
8636 USER_READ_LOGON |
8637 USER_READ_ACCOUNT;
8638 break;
8639
8640 case UserInternal1Information:
8641 case UserInternal2Information:
8642 case UserAllInformation:
8643 DesiredAccess = 0;
8644 break;
8645
8646 default:
8647 return STATUS_INVALID_INFO_CLASS;
8648 }
8649
8650 RtlAcquireResourceShared(&SampResource,
8651 TRUE);
8652
8653 /* Validate the domain handle */
8654 Status = SampValidateDbObject(UserHandle,
8655 SamDbUserObject,
8656 DesiredAccess,
8657 &UserObject);
8658 if (!NT_SUCCESS(Status))
8659 {
8660 TRACE("failed with status 0x%08lx\n", Status);
8661 goto done;
8662 }
8663
8664 switch (UserInformationClass)
8665 {
8666 case UserGeneralInformation:
8667 Status = SampQueryUserGeneral(UserObject,
8668 Buffer);
8669 break;
8670
8671 case UserPreferencesInformation:
8672 Status = SampQueryUserPreferences(UserObject,
8673 Buffer);
8674 break;
8675
8676 case UserLogonInformation:
8677 Status = SampQueryUserLogon(UserObject,
8678 Buffer);
8679 break;
8680
8681 case UserLogonHoursInformation:
8682 Status = SampQueryUserLogonHours(UserObject,
8683 Buffer);
8684 break;
8685
8686 case UserAccountInformation:
8687 Status = SampQueryUserAccount(UserObject,
8688 Buffer);
8689 break;
8690
8691 case UserNameInformation:
8692 Status = SampQueryUserName(UserObject,
8693 Buffer);
8694 break;
8695
8696 case UserAccountNameInformation:
8697 Status = SampQueryUserAccountName(UserObject,
8698 Buffer);
8699 break;
8700
8701 case UserFullNameInformation:
8702 Status = SampQueryUserFullName(UserObject,
8703 Buffer);
8704 break;
8705
8706 case UserPrimaryGroupInformation:
8707 Status = SampQueryUserPrimaryGroup(UserObject,
8708 Buffer);
8709 break;
8710
8711 case UserHomeInformation:
8712 Status = SampQueryUserHome(UserObject,
8713 Buffer);
8714 break;
8715
8716 case UserScriptInformation:
8717 Status = SampQueryUserScript(UserObject,
8718 Buffer);
8719 break;
8720
8721 case UserProfileInformation:
8722 Status = SampQueryUserProfile(UserObject,
8723 Buffer);
8724 break;
8725
8726 case UserAdminCommentInformation:
8727 Status = SampQueryUserAdminComment(UserObject,
8728 Buffer);
8729 break;
8730
8731 case UserWorkStationsInformation:
8732 Status = SampQueryUserWorkStations(UserObject,
8733 Buffer);
8734 break;
8735
8736 case UserControlInformation:
8737 Status = SampQueryUserControl(UserObject,
8738 Buffer);
8739 break;
8740
8741 case UserExpiresInformation:
8742 Status = SampQueryUserExpires(UserObject,
8743 Buffer);
8744 break;
8745
8746 case UserInternal1Information:
8747 Status = SampQueryUserInternal1(UserObject,
8748 Buffer);
8749 break;
8750
8751 case UserInternal2Information:
8752 Status = SampQueryUserInternal2(UserObject,
8753 Buffer);
8754 break;
8755
8756 case UserParametersInformation:
8757 Status = SampQueryUserParameters(UserObject,
8758 Buffer);
8759 break;
8760
8761 case UserAllInformation:
8762 Status = SampQueryUserAll(UserObject,
8763 Buffer);
8764 break;
8765
8766// case UserInternal4Information:
8767// case UserInternal5Information:
8768// case UserInternal4InformationNew:
8769// case UserInternal5InformationNew:
8770
8771 default:
8772 Status = STATUS_INVALID_INFO_CLASS;
8773 }
8774
8775done:
8776 RtlReleaseResource(&SampResource);
8777
8778 return Status;
8779}
8780
8781
8782/* Function 48 */
8783NTSTATUS
8784NTAPI
8785SamrQueryDisplayInformation2(IN SAMPR_HANDLE DomainHandle,
8786 IN DOMAIN_DISPLAY_INFORMATION DisplayInformationClass,
8787 IN unsigned long Index,
8788 IN unsigned long EntryCount,
8789 IN unsigned long PreferredMaximumLength,
8790 OUT unsigned long *TotalAvailable,
8791 OUT unsigned long *TotalReturned,
8792 OUT PSAMPR_DISPLAY_INFO_BUFFER Buffer)
8793{
8794 TRACE("SamrQueryDisplayInformation2(%p %lu %lu %lu %lu %p %p %p)\n",
8795 DomainHandle, DisplayInformationClass, Index,
8796 EntryCount, PreferredMaximumLength, TotalAvailable,
8797 TotalReturned, Buffer);
8798
8799 return SamrQueryDisplayInformation3(DomainHandle,
8800 DisplayInformationClass,
8801 Index,
8802 EntryCount,
8803 PreferredMaximumLength,
8804 TotalAvailable,
8805 TotalReturned,
8806 Buffer);
8807}
8808
8809
8810/* Function 49 */
8811NTSTATUS
8812NTAPI
8813SamrGetDisplayEnumerationIndex2(IN SAMPR_HANDLE DomainHandle,
8814 IN DOMAIN_DISPLAY_INFORMATION DisplayInformationClass,
8815 IN PRPC_UNICODE_STRING Prefix,
8816 OUT unsigned long *Index)
8817{
8818 TRACE("SamrGetDisplayEnumerationIndex2(%p %lu %p %p)\n",
8819 DomainHandle, DisplayInformationClass, Prefix, Index);
8820
8821 UNIMPLEMENTED;
8822 return STATUS_NOT_IMPLEMENTED;
8823}
8824
8825
8826/* Function 50 */
8827NTSTATUS
8828NTAPI
8829SamrCreateUser2InDomain(IN SAMPR_HANDLE DomainHandle,
8830 IN PRPC_UNICODE_STRING Name,
8831 IN unsigned long AccountType,
8832 IN ACCESS_MASK DesiredAccess,
8833 OUT SAMPR_HANDLE *UserHandle,
8834 OUT unsigned long *GrantedAccess,
8835 OUT unsigned long *RelativeId)
8836{
8837 SAM_DOMAIN_FIXED_DATA FixedDomainData;
8838 SAM_USER_FIXED_DATA FixedUserData;
8839 PSAM_DB_OBJECT DomainObject;
8840 PSAM_DB_OBJECT UserObject;
8841 GROUP_MEMBERSHIP GroupMembership;
8842 UCHAR LogonHours[23];
8843 ULONG ulSize;
8844 ULONG ulRid;
8845 WCHAR szRid[9];
8846 PSECURITY_DESCRIPTOR Sd = NULL;
8847 ULONG SdSize = 0;
8848 PSID UserSid = NULL;
8849 NTSTATUS Status;
8850
8851 TRACE("SamrCreateUserInDomain(%p %p %lx %p %p)\n",
8852 DomainHandle, Name, DesiredAccess, UserHandle, RelativeId);
8853
8854 if (Name == NULL ||
8855 Name->Length == 0 ||
8856 Name->Buffer == NULL ||
8857 UserHandle == NULL ||
8858 RelativeId == NULL)
8859 return STATUS_INVALID_PARAMETER;
8860
8861 /* Check for valid account type */
8862 if (AccountType != USER_NORMAL_ACCOUNT &&
8863 AccountType != USER_WORKSTATION_TRUST_ACCOUNT &&
8864 AccountType != USER_INTERDOMAIN_TRUST_ACCOUNT &&
8865 AccountType != USER_SERVER_TRUST_ACCOUNT &&
8866 AccountType != USER_TEMP_DUPLICATE_ACCOUNT)
8867 return STATUS_INVALID_PARAMETER;
8868
8869 /* Map generic access rights */
8870 RtlMapGenericMask(&DesiredAccess,
8871 &UserMapping);
8872
8873 RtlAcquireResourceExclusive(&SampResource,
8874 TRUE);
8875
8876 /* Validate the domain handle */
8877 Status = SampValidateDbObject(DomainHandle,
8878 SamDbDomainObject,
8879 DOMAIN_CREATE_USER,
8880 &DomainObject);
8881 if (!NT_SUCCESS(Status))
8882 {
8883 TRACE("failed with status 0x%08lx\n", Status);
8884 goto done;
8885 }
8886
8887 /* Check the user account name */
8888 Status = SampCheckAccountName(Name, 20);
8889 if (!NT_SUCCESS(Status))
8890 {
8891 TRACE("SampCheckAccountName failed (Status 0x%08lx)\n", Status);
8892 goto done;
8893 }
8894
8895 /* Check if the user name already exists in the domain */
8896 Status = SampCheckAccountNameInDomain(DomainObject,
8897 Name->Buffer);
8898 if (!NT_SUCCESS(Status))
8899 {
8900 TRACE("User name \'%S\' already exists in domain (Status 0x%08lx)\n",
8901 Name->Buffer, Status);
8902 goto done;
8903 }
8904
8905 /* Get the fixed domain attributes */
8906 ulSize = sizeof(SAM_DOMAIN_FIXED_DATA);
8907 Status = SampGetObjectAttribute(DomainObject,
8908 L"F",
8909 NULL,
8910 (PVOID)&FixedDomainData,
8911 &ulSize);
8912 if (!NT_SUCCESS(Status))
8913 {
8914 TRACE("failed with status 0x%08lx\n", Status);
8915 goto done;
8916 }
8917
8918 /* Increment the NextRid attribute */
8919 ulRid = FixedDomainData.NextRid;
8920 FixedDomainData.NextRid++;
8921
8922 TRACE("RID: %lx\n", ulRid);
8923
8924 /* Create the user SID */
8925 Status = SampCreateAccountSid(DomainObject,
8926 ulRid,
8927 &UserSid);
8928 if (!NT_SUCCESS(Status))
8929 {
8930 TRACE("SampCreateAccountSid failed (Status 0x%08lx)\n", Status);
8931 goto done;
8932 }
8933
8934 /* Create the security descriptor */
8935 Status = SampCreateUserSD(UserSid,
8936 &Sd,
8937 &SdSize);
8938 if (!NT_SUCCESS(Status))
8939 {
8940 TRACE("SampCreateUserSD failed (Status 0x%08lx)\n", Status);
8941 goto done;
8942 }
8943
8944 /* Store the fixed domain attributes */
8945 Status = SampSetObjectAttribute(DomainObject,
8946 L"F",
8947 REG_BINARY,
8948 &FixedDomainData,
8949 ulSize);
8950 if (!NT_SUCCESS(Status))
8951 {
8952 TRACE("failed with status 0x%08lx\n", Status);
8953 goto done;
8954 }
8955
8956 /* Convert the RID into a string (hex) */
8957 _swprintf(szRid, L"%08lX", ulRid);
8958
8959 /* Create the user object */
8960 Status = SampCreateDbObject(DomainObject,
8961 L"Users",
8962 szRid,
8963 ulRid,
8964 SamDbUserObject,
8965 DesiredAccess,
8966 &UserObject);
8967 if (!NT_SUCCESS(Status))
8968 {
8969 TRACE("failed with status 0x%08lx\n", Status);
8970 goto done;
8971 }
8972
8973 /* Add the account name for the user object */
8974 Status = SampSetAccountNameInDomain(DomainObject,
8975 L"Users",
8976 Name->Buffer,
8977 ulRid);
8978 if (!NT_SUCCESS(Status))
8979 {
8980 TRACE("failed with status 0x%08lx\n", Status);
8981 goto done;
8982 }
8983
8984 /* Initialize fixed user data */
8985 FixedUserData.Version = 1;
8986 FixedUserData.Reserved = 0;
8987 FixedUserData.LastLogon.QuadPart = 0;
8988 FixedUserData.LastLogoff.QuadPart = 0;
8989 FixedUserData.PasswordLastSet.QuadPart = 0;
8990 FixedUserData.AccountExpires.LowPart = MAXULONG;
8991 FixedUserData.AccountExpires.HighPart = MAXLONG;
8992 FixedUserData.LastBadPasswordTime.QuadPart = 0;
8993 FixedUserData.UserId = ulRid;
8994 FixedUserData.PrimaryGroupId = DOMAIN_GROUP_RID_USERS;
8995 FixedUserData.UserAccountControl = USER_ACCOUNT_DISABLED |
8996 USER_PASSWORD_NOT_REQUIRED |
8997 AccountType;
8998 FixedUserData.CountryCode = 0;
8999 FixedUserData.CodePage = 0;
9000 FixedUserData.BadPasswordCount = 0;
9001 FixedUserData.LogonCount = 0;
9002 FixedUserData.AdminCount = 0;
9003 FixedUserData.OperatorCount = 0;
9004
9005 /* Set fixed user data attribute */
9006 Status = SampSetObjectAttribute(UserObject,
9007 L"F",
9008 REG_BINARY,
9009 (LPVOID)&FixedUserData,
9010 sizeof(SAM_USER_FIXED_DATA));
9011 if (!NT_SUCCESS(Status))
9012 {
9013 TRACE("failed with status 0x%08lx\n", Status);
9014 goto done;
9015 }
9016
9017 /* Set the Name attribute */
9018 Status = SampSetObjectAttributeString(UserObject,
9019 L"Name",
9020 Name);
9021 if (!NT_SUCCESS(Status))
9022 {
9023 TRACE("failed with status 0x%08lx\n", Status);
9024 goto done;
9025 }
9026
9027 /* Set the FullName attribute */
9028 Status = SampSetObjectAttributeString(UserObject,
9029 L"FullName",
9030 NULL);
9031 if (!NT_SUCCESS(Status))
9032 {
9033 TRACE("failed with status 0x%08lx\n", Status);
9034 goto done;
9035 }
9036
9037 /* Set the HomeDirectory attribute */
9038 Status = SampSetObjectAttributeString(UserObject,
9039 L"HomeDirectory",
9040 NULL);
9041 if (!NT_SUCCESS(Status))
9042 {
9043 TRACE("failed with status 0x%08lx\n", Status);
9044 goto done;
9045 }
9046
9047 /* Set the HomeDirectoryDrive attribute */
9048 Status = SampSetObjectAttributeString(UserObject,
9049 L"HomeDirectoryDrive",
9050 NULL);
9051 if (!NT_SUCCESS(Status))
9052 {
9053 TRACE("failed with status 0x%08lx\n", Status);
9054 goto done;
9055 }
9056
9057 /* Set the ScriptPath attribute */
9058 Status = SampSetObjectAttributeString(UserObject,
9059 L"ScriptPath",
9060 NULL);
9061 if (!NT_SUCCESS(Status))
9062 {
9063 TRACE("failed with status 0x%08lx\n", Status);
9064 goto done;
9065 }
9066
9067 /* Set the ProfilePath attribute */
9068 Status = SampSetObjectAttributeString(UserObject,
9069 L"ProfilePath",
9070 NULL);
9071 if (!NT_SUCCESS(Status))
9072 {
9073 TRACE("failed with status 0x%08lx\n", Status);
9074 goto done;
9075 }
9076
9077 /* Set the AdminComment attribute */
9078 Status = SampSetObjectAttributeString(UserObject,
9079 L"AdminComment",
9080 NULL);
9081 if (!NT_SUCCESS(Status))
9082 {
9083 TRACE("failed with status 0x%08lx\n", Status);
9084 goto done;
9085 }
9086
9087 /* Set the UserComment attribute */
9088 Status = SampSetObjectAttributeString(UserObject,
9089 L"UserComment",
9090 NULL);
9091 if (!NT_SUCCESS(Status))
9092 {
9093 TRACE("failed with status 0x%08lx\n", Status);
9094 goto done;
9095 }
9096
9097 /* Set the WorkStations attribute */
9098 Status = SampSetObjectAttributeString(UserObject,
9099 L"WorkStations",
9100 NULL);
9101 if (!NT_SUCCESS(Status))
9102 {
9103 TRACE("failed with status 0x%08lx\n", Status);
9104 goto done;
9105 }
9106
9107 /* Set the Parameters attribute */
9108 Status = SampSetObjectAttributeString(UserObject,
9109 L"Parameters",
9110 NULL);
9111 if (!NT_SUCCESS(Status))
9112 {
9113 TRACE("failed with status 0x%08lx\n", Status);
9114 goto done;
9115 }
9116
9117 /* Set LogonHours attribute*/
9118 *((PUSHORT)LogonHours) = 168;
9119 memset(&(LogonHours[2]), 0xff, 21);
9120
9121 Status = SampSetObjectAttribute(UserObject,
9122 L"LogonHours",
9123 REG_BINARY,
9124 &LogonHours,
9125 sizeof(LogonHours));
9126 if (!NT_SUCCESS(Status))
9127 {
9128 TRACE("failed with status 0x%08lx\n", Status);
9129 goto done;
9130 }
9131
9132 /* Set Groups attribute*/
9133 GroupMembership.RelativeId = DOMAIN_GROUP_RID_USERS;
9134 GroupMembership.Attributes = SE_GROUP_MANDATORY |
9135 SE_GROUP_ENABLED |
9136 SE_GROUP_ENABLED_BY_DEFAULT;
9137
9138 Status = SampSetObjectAttribute(UserObject,
9139 L"Groups",
9140 REG_BINARY,
9141 &GroupMembership,
9142 sizeof(GROUP_MEMBERSHIP));
9143 if (!NT_SUCCESS(Status))
9144 {
9145 TRACE("failed with status 0x%08lx\n", Status);
9146 goto done;
9147 }
9148
9149 /* Set LMPwd attribute*/
9150 Status = SampSetObjectAttribute(UserObject,
9151 L"LMPwd",
9152 REG_BINARY,
9153 NULL,
9154 0);
9155 if (!NT_SUCCESS(Status))
9156 {
9157 TRACE("failed with status 0x%08lx\n", Status);
9158 goto done;
9159 }
9160
9161 /* Set NTPwd attribute*/
9162 Status = SampSetObjectAttribute(UserObject,
9163 L"NTPwd",
9164 REG_BINARY,
9165 NULL,
9166 0);
9167 if (!NT_SUCCESS(Status))
9168 {
9169 TRACE("failed with status 0x%08lx\n", Status);
9170 goto done;
9171 }
9172
9173 /* Set LMPwdHistory attribute*/
9174 Status = SampSetObjectAttribute(UserObject,
9175 L"LMPwdHistory",
9176 REG_BINARY,
9177 NULL,
9178 0);
9179 if (!NT_SUCCESS(Status))
9180 {
9181 TRACE("failed with status 0x%08lx\n", Status);
9182 goto done;
9183 }
9184
9185 /* Set NTPwdHistory attribute*/
9186 Status = SampSetObjectAttribute(UserObject,
9187 L"NTPwdHistory",
9188 REG_BINARY,
9189 NULL,
9190 0);
9191 if (!NT_SUCCESS(Status))
9192 {
9193 TRACE("failed with status 0x%08lx\n", Status);
9194 goto done;
9195 }
9196
9197 /* Set the PrivateData attribute */
9198 Status = SampSetObjectAttributeString(UserObject,
9199 L"PrivateData",
9200 NULL);
9201 if (!NT_SUCCESS(Status))
9202 {
9203 TRACE("failed with status 0x%08lx\n", Status);
9204 goto done;
9205 }
9206
9207 /* Set the SecDesc attribute*/
9208 Status = SampSetObjectAttribute(UserObject,
9209 L"SecDesc",
9210 REG_BINARY,
9211 Sd,
9212 SdSize);
9213 if (!NT_SUCCESS(Status))
9214 {
9215 TRACE("failed with status 0x%08lx\n", Status);
9216 goto done;
9217 }
9218
9219 if (NT_SUCCESS(Status))
9220 {
9221 *UserHandle = (SAMPR_HANDLE)UserObject;
9222 *RelativeId = ulRid;
9223 *GrantedAccess = UserObject->Access;
9224 }
9225
9226done:
9227 if (Sd != NULL)
9228 RtlFreeHeap(RtlGetProcessHeap(), 0, Sd);
9229
9230 if (UserSid != NULL)
9231 RtlFreeHeap(RtlGetProcessHeap(), 0, UserSid);
9232
9233 RtlReleaseResource(&SampResource);
9234
9235 TRACE("returns with status 0x%08lx\n", Status);
9236
9237 return Status;
9238}
9239
9240
9241/* Function 51 */
9242NTSTATUS
9243NTAPI
9244SamrQueryDisplayInformation3(IN SAMPR_HANDLE DomainHandle,
9245 IN DOMAIN_DISPLAY_INFORMATION DisplayInformationClass,
9246 IN unsigned long Index,
9247 IN unsigned long EntryCount,
9248 IN unsigned long PreferredMaximumLength,
9249 OUT unsigned long *TotalAvailable,
9250 OUT unsigned long *TotalReturned,
9251 OUT PSAMPR_DISPLAY_INFO_BUFFER Buffer)
9252{
9253 PSAM_DB_OBJECT DomainObject;
9254 NTSTATUS Status;
9255
9256 FIXME("SamrQueryDisplayInformation3(%p %lu %lu %lu %lu %p %p %p)\n",
9257 DomainHandle, DisplayInformationClass, Index,
9258 EntryCount, PreferredMaximumLength, TotalAvailable,
9259 TotalReturned, Buffer);
9260
9261 RtlAcquireResourceShared(&SampResource,
9262 TRUE);
9263
9264 /* Validate the domain handle */
9265 Status = SampValidateDbObject(DomainHandle,
9266 SamDbDomainObject,
9267 DOMAIN_LIST_ACCOUNTS,
9268 &DomainObject);
9269 if (!NT_SUCCESS(Status))
9270 {
9271 ERR("SampValidateDbObject() failed (Status 0x%08lx)\n", Status);
9272 goto done;
9273 }
9274
9275 Status = SampFillDisplayCache(DomainObject,
9276 DisplayInformationClass);
9277 if (!NT_SUCCESS(Status))
9278 {
9279 ERR("SampFillDisplayCache() failed (Status 0x%08lx)\n", Status);
9280 goto done;
9281 }
9282
9283done:
9284 TRACE("returns with status 0x%08lx\n", Status);
9285
9286 RtlReleaseResource(&SampResource);
9287
9288// return Status;
9289 return STATUS_NOT_IMPLEMENTED;
9290}
9291
9292
9293/* Function 52 */
9294NTSTATUS
9295NTAPI
9296SamrAddMultipleMembersToAlias(IN SAMPR_HANDLE AliasHandle,
9297 IN PSAMPR_PSID_ARRAY MembersBuffer)
9298{
9299 ULONG i;
9300 NTSTATUS Status = STATUS_SUCCESS;
9301
9302 TRACE("SamrAddMultipleMembersToAlias(%p %p)\n",
9303 AliasHandle, MembersBuffer);
9304
9305 for (i = 0; i < MembersBuffer->Count; i++)
9306 {
9307 Status = SamrAddMemberToAlias(AliasHandle,
9308 ((PSID *)MembersBuffer->Sids)[i]);
9309
9310 if (Status == STATUS_MEMBER_IN_ALIAS)
9311 Status = STATUS_SUCCESS;
9312
9313 if (!NT_SUCCESS(Status))
9314 break;
9315 }
9316
9317 return Status;
9318}
9319
9320
9321/* Function 53 */
9322NTSTATUS
9323NTAPI
9324SamrRemoveMultipleMembersFromAlias(IN SAMPR_HANDLE AliasHandle,
9325 IN PSAMPR_PSID_ARRAY MembersBuffer)
9326{
9327 ULONG i;
9328 NTSTATUS Status = STATUS_SUCCESS;
9329
9330 TRACE("SamrRemoveMultipleMembersFromAlias(%p %p)\n",
9331 AliasHandle, MembersBuffer);
9332
9333 for (i = 0; i < MembersBuffer->Count; i++)
9334 {
9335 Status = SamrRemoveMemberFromAlias(AliasHandle,
9336 ((PSID *)MembersBuffer->Sids)[i]);
9337
9338 if (Status == STATUS_MEMBER_IN_ALIAS)
9339 Status = STATUS_SUCCESS;
9340
9341 if (!NT_SUCCESS(Status))
9342 break;
9343 }
9344
9345 return Status;
9346}
9347
9348
9349/* Function 54 */
9350NTSTATUS
9351NTAPI
9352SamrOemChangePasswordUser2(IN handle_t BindingHandle,
9353 IN PRPC_STRING ServerName,
9354 IN PRPC_STRING UserName,
9355 IN PSAMPR_ENCRYPTED_USER_PASSWORD NewPasswordEncryptedWithOldLm,
9356 IN PENCRYPTED_LM_OWF_PASSWORD OldLmOwfPasswordEncryptedWithNewLm)
9357{
9358 UNIMPLEMENTED;
9359 return STATUS_NOT_IMPLEMENTED;
9360}
9361
9362/* Function 55 */
9363NTSTATUS
9364NTAPI
9365SamrUnicodeChangePasswordUser2(IN handle_t BindingHandle,
9366 IN PRPC_UNICODE_STRING ServerName,
9367 IN PRPC_UNICODE_STRING UserName,
9368 IN PSAMPR_ENCRYPTED_USER_PASSWORD NewPasswordEncryptedWithOldNt,
9369 IN PENCRYPTED_NT_OWF_PASSWORD OldNtOwfPasswordEncryptedWithNewNt,
9370 IN unsigned char LmPresent,
9371 IN PSAMPR_ENCRYPTED_USER_PASSWORD NewPasswordEncryptedWithOldLm,
9372 IN PENCRYPTED_LM_OWF_PASSWORD OldLmOwfPasswordEncryptedWithNewNt)
9373{
9374 UNIMPLEMENTED;
9375 return STATUS_NOT_IMPLEMENTED;
9376}
9377
9378
9379/* Function 56 */
9380NTSTATUS
9381NTAPI
9382SamrGetDomainPasswordInformation(IN handle_t BindingHandle,
9383 IN PRPC_UNICODE_STRING Unused,
9384 OUT PUSER_DOMAIN_PASSWORD_INFORMATION PasswordInformation)
9385{
9386 SAMPR_HANDLE ServerHandle = NULL;
9387 PSAM_DB_OBJECT DomainObject = NULL;
9388 SAM_DOMAIN_FIXED_DATA FixedData;
9389 ULONG Length;
9390 NTSTATUS Status;
9391
9392 TRACE("SamrGetDomainPasswordInformation(%p %p %p)\n",
9393 BindingHandle, Unused, PasswordInformation);
9394
9395 Status = SamrConnect(NULL,
9396 &ServerHandle,
9397 SAM_SERVER_LOOKUP_DOMAIN);
9398 if (!NT_SUCCESS(Status))
9399 {
9400 TRACE("SamrConnect() failed (Status 0x%08lx)\n", Status);
9401 goto done;
9402 }
9403
9404 Status = SampOpenDbObject((PSAM_DB_OBJECT)ServerHandle,
9405 L"Domains",
9406 L"Account",
9407 0,
9408 SamDbDomainObject,
9409 DOMAIN_READ_PASSWORD_PARAMETERS,
9410 &DomainObject);
9411 if (!NT_SUCCESS(Status))
9412 {
9413 TRACE("SampOpenDbObject() failed (Status 0x%08lx)\n", Status);
9414 goto done;
9415 }
9416
9417 Length = sizeof(SAM_DOMAIN_FIXED_DATA);
9418 Status = SampGetObjectAttribute(DomainObject,
9419 L"F",
9420 NULL,
9421 &FixedData,
9422 &Length);
9423 if (!NT_SUCCESS(Status))
9424 {
9425 TRACE("SampGetObjectAttribute() failed (Status 0x%08lx)\n", Status);
9426 goto done;
9427 }
9428
9429 PasswordInformation->MinPasswordLength = FixedData.MinPasswordLength;
9430 PasswordInformation->PasswordProperties = FixedData.PasswordProperties;
9431
9432done:
9433 if (DomainObject != NULL)
9434 SampCloseDbObject(DomainObject);
9435
9436 if (ServerHandle != NULL)
9437 SamrCloseHandle(&ServerHandle);
9438
9439 return Status;
9440}
9441
9442
9443/* Function 57 */
9444NTSTATUS
9445NTAPI
9446SamrConnect2(IN PSAMPR_SERVER_NAME ServerName,
9447 OUT SAMPR_HANDLE *ServerHandle,
9448 IN ACCESS_MASK DesiredAccess)
9449{
9450 SAMPR_REVISION_INFO InRevisionInfo, OutRevisionInfo;
9451 ULONG OutVersion;
9452
9453 TRACE("SamrConnect2(%p %p %lx)\n",
9454 ServerName, ServerHandle, DesiredAccess);
9455
9456 InRevisionInfo.V1.Revision = 1;
9457 InRevisionInfo.V1.SupportedFeatures = 0;
9458
9459 return SamrConnect5(ServerName,
9460 DesiredAccess,
9461 1,
9462 &InRevisionInfo,
9463 &OutVersion,
9464 &OutRevisionInfo,
9465 ServerHandle);
9466}
9467
9468
9469/* Function 58 */
9470NTSTATUS
9471NTAPI
9472SamrSetInformationUser2(IN SAMPR_HANDLE UserHandle,
9473 IN USER_INFORMATION_CLASS UserInformationClass,
9474 IN PSAMPR_USER_INFO_BUFFER Buffer)
9475{
9476 PSAM_DB_OBJECT UserObject;
9477 ACCESS_MASK DesiredAccess;
9478 NTSTATUS Status;
9479
9480 TRACE("SamrSetInformationUser2(%p %lu %p)\n",
9481 UserHandle, UserInformationClass, Buffer);
9482
9483 switch (UserInformationClass)
9484 {
9485 case UserLogonHoursInformation:
9486 case UserNameInformation:
9487 case UserAccountNameInformation:
9488 case UserFullNameInformation:
9489 case UserPrimaryGroupInformation:
9490 case UserHomeInformation:
9491 case UserScriptInformation:
9492 case UserProfileInformation:
9493 case UserAdminCommentInformation:
9494 case UserWorkStationsInformation:
9495 case UserControlInformation:
9496 case UserExpiresInformation:
9497 case UserParametersInformation:
9498 DesiredAccess = USER_WRITE_ACCOUNT;
9499 break;
9500
9501 case UserGeneralInformation:
9502 DesiredAccess = USER_WRITE_ACCOUNT |
9503 USER_WRITE_PREFERENCES;
9504 break;
9505
9506 case UserPreferencesInformation:
9507 DesiredAccess = USER_WRITE_PREFERENCES;
9508 break;
9509
9510 case UserSetPasswordInformation:
9511 case UserInternal1Information:
9512 DesiredAccess = USER_FORCE_PASSWORD_CHANGE;
9513 break;
9514
9515 case UserAllInformation:
9516 case UserInternal2Information:
9517 DesiredAccess = 0; /* FIXME */
9518 break;
9519
9520 default:
9521 return STATUS_INVALID_INFO_CLASS;
9522 }
9523
9524 RtlAcquireResourceExclusive(&SampResource,
9525 TRUE);
9526
9527 /* Validate the domain handle */
9528 Status = SampValidateDbObject(UserHandle,
9529 SamDbUserObject,
9530 DesiredAccess,
9531 &UserObject);
9532 if (!NT_SUCCESS(Status))
9533 {
9534 TRACE("failed with status 0x%08lx\n", Status);
9535 goto done;
9536 }
9537
9538 switch (UserInformationClass)
9539 {
9540 case UserGeneralInformation:
9541 Status = SampSetUserGeneral(UserObject,
9542 Buffer);
9543 break;
9544
9545 case UserPreferencesInformation:
9546 Status = SampSetUserPreferences(UserObject,
9547 Buffer);
9548 break;
9549
9550 case UserLogonHoursInformation:
9551 Status = SampSetLogonHoursAttribute(UserObject,
9552 &Buffer->LogonHours.LogonHours);
9553 break;
9554
9555 case UserNameInformation:
9556 Status = SampSetUserName(UserObject,
9557 &Buffer->Name.UserName);
9558 if (!NT_SUCCESS(Status))
9559 break;
9560
9561 Status = SampSetObjectAttributeString(UserObject,
9562 L"FullName",
9563 &Buffer->Name.FullName);
9564 break;
9565
9566 case UserAccountNameInformation:
9567 Status = SampSetUserName(UserObject,
9568 &Buffer->AccountName.UserName);
9569 break;
9570
9571 case UserFullNameInformation:
9572 Status = SampSetObjectAttributeString(UserObject,
9573 L"FullName",
9574 &Buffer->FullName.FullName);
9575 break;
9576
9577 case UserPrimaryGroupInformation:
9578 Status = SampSetUserPrimaryGroup(UserObject,
9579 Buffer);
9580 break;
9581
9582 case UserHomeInformation:
9583 Status = SampSetObjectAttributeString(UserObject,
9584 L"HomeDirectory",
9585 &Buffer->Home.HomeDirectory);
9586 if (!NT_SUCCESS(Status))
9587 break;
9588
9589 Status = SampSetObjectAttributeString(UserObject,
9590 L"HomeDirectoryDrive",
9591 &Buffer->Home.HomeDirectoryDrive);
9592 break;
9593
9594 case UserScriptInformation:
9595 Status = SampSetObjectAttributeString(UserObject,
9596 L"ScriptPath",
9597 &Buffer->Script.ScriptPath);
9598 break;
9599
9600 case UserProfileInformation:
9601 Status = SampSetObjectAttributeString(UserObject,
9602 L"ProfilePath",
9603 &Buffer->Profile.ProfilePath);
9604 break;
9605
9606 case UserAdminCommentInformation:
9607 Status = SampSetObjectAttributeString(UserObject,
9608 L"AdminComment",
9609 &Buffer->AdminComment.AdminComment);
9610 break;
9611
9612 case UserWorkStationsInformation:
9613 Status = SampSetObjectAttributeString(UserObject,
9614 L"WorkStations",
9615 &Buffer->WorkStations.WorkStations);
9616 break;
9617
9618 case UserSetPasswordInformation:
9619 TRACE("Password: %S\n", Buffer->SetPassword.Password.Buffer);
9620 TRACE("PasswordExpired: %d\n", Buffer->SetPassword.PasswordExpired);
9621
9622 Status = SampSetObjectAttributeString(UserObject,
9623 L"Password",
9624 &Buffer->SetPassword.Password);
9625 break;
9626
9627 case UserControlInformation:
9628 Status = SampSetUserControl(UserObject,
9629 Buffer);
9630 break;
9631
9632 case UserExpiresInformation:
9633 Status = SampSetUserExpires(UserObject,
9634 Buffer);
9635 break;
9636
9637 case UserInternal1Information:
9638 Status = SampSetUserInternal1(UserObject,
9639 Buffer);
9640 break;
9641
9642 case UserInternal2Information:
9643 Status = SampSetUserInternal2(UserObject,
9644 Buffer);
9645 break;
9646
9647 case UserParametersInformation:
9648 Status = SampSetObjectAttributeString(UserObject,
9649 L"Parameters",
9650 &Buffer->Parameters.Parameters);
9651 break;
9652
9653 case UserAllInformation:
9654 Status = SampSetUserAll(UserObject,
9655 Buffer);
9656 break;
9657
9658// case UserInternal4Information:
9659// case UserInternal5Information:
9660// case UserInternal4InformationNew:
9661// case UserInternal5InformationNew:
9662
9663 default:
9664 Status = STATUS_INVALID_INFO_CLASS;
9665 }
9666
9667done:
9668 RtlReleaseResource(&SampResource);
9669
9670 return Status;
9671}
9672
9673
9674/* Function 59 */
9675NTSTATUS
9676NTAPI
9677SamrSetBootKeyInformation(IN handle_t BindingHandle) /* FIXME */
9678{
9679 UNIMPLEMENTED;
9680 return STATUS_NOT_IMPLEMENTED;
9681}
9682
9683/* Function 60 */
9684NTSTATUS
9685NTAPI
9686SamrGetBootKeyInformation(IN handle_t BindingHandle) /* FIXME */
9687{
9688 UNIMPLEMENTED;
9689 return STATUS_NOT_IMPLEMENTED;
9690}
9691
9692/* Function 61 */
9693NTSTATUS
9694NTAPI
9695SamrConnect3(IN handle_t BindingHandle) /* FIXME */
9696{
9697 UNIMPLEMENTED;
9698 return STATUS_NOT_IMPLEMENTED;
9699}
9700
9701
9702/* Function 62 */
9703NTSTATUS
9704NTAPI
9705SamrConnect4(IN PSAMPR_SERVER_NAME ServerName,
9706 OUT SAMPR_HANDLE *ServerHandle,
9707 IN unsigned long ClientRevision,
9708 IN ACCESS_MASK DesiredAccess)
9709{
9710 SAMPR_REVISION_INFO InRevisionInfo, OutRevisionInfo;
9711 ULONG OutVersion;
9712
9713 TRACE("SamrConnect4(%p %p %lu 0x%lx)\n",
9714 ServerName, ServerHandle, ClientRevision, DesiredAccess);
9715
9716 InRevisionInfo.V1.Revision = 2;
9717 InRevisionInfo.V1.SupportedFeatures = 0;
9718
9719 return SamrConnect5(ServerName,
9720 DesiredAccess,
9721 1,
9722 &InRevisionInfo,
9723 &OutVersion,
9724 &OutRevisionInfo,
9725 ServerHandle);
9726}
9727
9728
9729/* Function 63 */
9730NTSTATUS
9731NTAPI
9732SamrUnicodeChangePasswordUser3(IN handle_t BindingHandle) /* FIXME */
9733{
9734 UNIMPLEMENTED;
9735 return STATUS_NOT_IMPLEMENTED;
9736}
9737
9738
9739/* Function 64 */
9740NTSTATUS
9741NTAPI
9742SamrConnect5(IN PSAMPR_SERVER_NAME ServerName,
9743 IN ACCESS_MASK DesiredAccess,
9744 IN unsigned long InVersion,
9745 IN SAMPR_REVISION_INFO *InRevisionInfo,
9746 OUT unsigned long *OutVersion,
9747 OUT SAMPR_REVISION_INFO *OutRevisionInfo,
9748 OUT SAMPR_HANDLE *ServerHandle)
9749{
9750 PSAM_DB_OBJECT ServerObject;
9751 NTSTATUS Status;
9752
9753 TRACE("SamrConnect5(%p 0x%lx %lu %p %p %p %p)\n",
9754 ServerName, DesiredAccess, InVersion, InRevisionInfo,
9755 OutVersion, OutRevisionInfo, ServerHandle);
9756
9757 if (InVersion != 1)
9758 return STATUS_NOT_SUPPORTED;
9759
9760 RtlAcquireResourceShared(&SampResource,
9761 TRUE);
9762
9763 /* Map generic access rights */
9764 RtlMapGenericMask(&DesiredAccess,
9765 &ServerMapping);
9766
9767 /* Open the Server Object */
9768 Status = SampOpenDbObject(NULL,
9769 NULL,
9770 L"SAM",
9771 0,
9772 SamDbServerObject,
9773 DesiredAccess,
9774 &ServerObject);
9775 if (NT_SUCCESS(Status))
9776 {
9777 *OutVersion = 1;
9778
9779 OutRevisionInfo->V1.Revision = 3;
9780 OutRevisionInfo->V1.SupportedFeatures = 0;
9781
9782 *ServerHandle = (SAMPR_HANDLE)ServerObject;
9783 }
9784
9785 RtlReleaseResource(&SampResource);
9786
9787 TRACE("SamrConnect5 done (Status 0x%08lx)\n", Status);
9788
9789 return Status;
9790}
9791
9792
9793/* Function 65 */
9794NTSTATUS
9795NTAPI
9796SamrRidToSid(IN SAMPR_HANDLE ObjectHandle,
9797 IN unsigned long Rid,
9798 OUT PRPC_SID *Sid)
9799{
9800 UNIMPLEMENTED;
9801 return STATUS_NOT_IMPLEMENTED;
9802}
9803
9804/* Function 66 */
9805NTSTATUS
9806NTAPI
9807SamrSetDSRMPassword(IN handle_t BindingHandle,
9808 IN PRPC_UNICODE_STRING Unused,
9809 IN unsigned long UserId,
9810 IN PENCRYPTED_NT_OWF_PASSWORD EncryptedNtOwfPassword)
9811{
9812 UNIMPLEMENTED;
9813 return STATUS_NOT_IMPLEMENTED;
9814}
9815
9816/* Function 67 */
9817NTSTATUS
9818NTAPI
9819SamrValidatePassword(IN handle_t Handle,
9820 IN PASSWORD_POLICY_VALIDATION_TYPE ValidationType,
9821 IN PSAM_VALIDATE_INPUT_ARG InputArg,
9822 OUT PSAM_VALIDATE_OUTPUT_ARG *OutputArg)
9823{
9824 UNIMPLEMENTED;
9825 return STATUS_NOT_IMPLEMENTED;
9826}
9827
9828/* EOF */
Names
PWSTR Names[]
Definition: RtlGenerate8dot3Name.c:34
BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127
SAMPR_HANDLE
void * SAMPR_HANDLE
Definition: authpackage.c:113
PSAMPR_SERVER_NAME
wchar_t * PSAMPR_SERVER_NAME
Definition: authpackage.c:112
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
Group
@ Group
Definition: help.c:22
FIXME
#define FIXME(fmt,...)
Definition: precomp.h:53
WARN
#define WARN(fmt,...)
Definition: precomp.h:61
ERR
#define ERR(fmt,...)
Definition: precomp.h:57
UNIMPLEMENTED
#define UNIMPLEMENTED
Definition: ntoskrnl.c:15
RtlAllocateHeap
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:616
RtlFreeHeap
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:634
Found
return Found
Definition: dirsup.c:1270
Buffer
Definition: bufpool.h:45
STATUS_INVALID_HANDLE
#define STATUS_INVALID_HANDLE
Definition: d3dkmdt.h:40
STATUS_NOT_SUPPORTED
#define STATUS_NOT_SUPPORTED
Definition: d3dkmdt.h:48
STATUS_NOT_IMPLEMENTED
#define STATUS_NOT_IMPLEMENTED
Definition: d3dkmdt.h:42
Name
LPWSTR Name
Definition: desk.c:124
MIDL_user_free
void __RPC_USER MIDL_user_free(void __RPC_FAR *ptr)
Definition: dhcpcsvc.c:31
MIDL_user_allocate
void __RPC_FAR *__RPC_USER MIDL_user_allocate(SIZE_T len)
Definition: dhcpcsvc.c:26
Attributes
_In_ ULONG Attributes
Definition: dispmprt.h:1077
DataLength
_In_ D3DDDI_VIDEO_PRESENT_TARGET_ID _In_ ULONG _In_ ULONG DataLength
Definition: dispmprt.h:233
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:736
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
HeapAlloc
#define HeapAlloc
Definition: compat.h:733
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:735
HEAP_ZERO_MEMORY
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
wcstoul
_ACRTIMP __msvcrt_ulong __cdecl wcstoul(const wchar_t *, wchar_t **, int)
Definition: wcs.c:2917
memcmp
_ACRTIMP int __cdecl memcmp(const void *, const void *, size_t)
Definition: string.c:2807
SampGetMembersInAlias
NTSTATUS SampGetMembersInAlias(IN PSAM_DB_OBJECT AliasObject, OUT PULONG MemberCount, OUT PSAMPR_SID_INFORMATION *MemberArray)
Definition: alias.c:218
SampRemoveAllMembersFromAlias
NTSTATUS SampRemoveAllMembersFromAlias(IN PSAM_DB_OBJECT AliasObject)
Definition: alias.c:314
SampAddMemberToAlias
NTSTATUS SampAddMemberToAlias(IN PSAM_DB_OBJECT AliasObject, IN PRPC_SID MemberId)
Definition: alias.c:39
SampRemoveMemberFromAlias
NTSTATUS NTAPI SampRemoveMemberFromAlias(IN PSAM_DB_OBJECT AliasObject, IN PRPC_SID MemberId)
Definition: alias.c:111
SampGetObjectAttribute
NTSTATUS SampGetObjectAttribute(PSAM_DB_OBJECT DbObject, LPWSTR AttributeName, PULONG AttributeType, LPVOID AttributeData, PULONG AttributeSize)
Definition: database.c:516
SampSetObjectAttribute
NTSTATUS SampSetObjectAttribute(PSAM_DB_OBJECT DbObject, LPWSTR AttributeName, ULONG AttributeType, LPVOID AttributeData, ULONG AttributeSize)
Definition: database.c:501
SampCloseDbObject
NTSTATUS SampCloseDbObject(PSAM_DB_OBJECT DbObject)
Definition: database.c:346
SampOpenDbObject
NTSTATUS SampOpenDbObject(IN PSAM_DB_OBJECT ParentObject, IN LPWSTR ContainerName, IN LPWSTR ObjectName, IN ULONG RelativeId, IN SAM_DB_OBJECT_TYPE ObjectType, IN ACCESS_MASK DesiredAccess, OUT PSAM_DB_OBJECT *DbObject)
Definition: database.c:173
SampDeleteAccountDbObject
NTSTATUS SampDeleteAccountDbObject(PSAM_DB_OBJECT DbObject)
Definition: database.c:368
SampValidateDbObject
NTSTATUS SampValidateDbObject(SAMPR_HANDLE Handle, SAM_DB_OBJECT_TYPE ObjectType, ACCESS_MASK DesiredAccess, PSAM_DB_OBJECT *DbObject)
Definition: database.c:301
SampCreateDbObject
NTSTATUS SampCreateDbObject(IN PSAM_DB_OBJECT ParentObject, IN LPWSTR ContainerName, IN LPWSTR ObjectName, IN ULONG RelativeId, IN SAM_DB_OBJECT_TYPE ObjectType, IN ACCESS_MASK DesiredAccess, OUT PSAM_DB_OBJECT *DbObject)
Definition: database.c:44
SampSetObjectAttributeString
NTSTATUS SampSetObjectAttributeString(PSAM_DB_OBJECT DbObject, LPWSTR AttributeName, PRPC_UNICODE_STRING String)
Definition: database.c:595
SampGetObjectAttributeString
NTSTATUS SampGetObjectAttributeString(PSAM_DB_OBJECT DbObject, LPWSTR AttributeName, PRPC_UNICODE_STRING String)
Definition: database.c:531
SampFillDisplayCache
NTSTATUS SampFillDisplayCache(_In_ PSAM_DB_OBJECT DomainObject, _In_ DOMAIN_DISPLAY_INFORMATION DisplayInformationClass)
Definition: display.c:172
SampShutdownDisplayCache
NTSTATUS SampShutdownDisplayCache(VOID)
Definition: display.c:164
SampSetAccountNameInDomain
NTSTATUS SampSetAccountNameInDomain(IN PSAM_DB_OBJECT DomainObject, IN LPCWSTR lpContainerName, IN LPCWSTR lpAccountName, IN ULONG ulRelativeId)
Definition: domain.c:14
SampRemoveAccountNameFromDomain
NTSTATUS SampRemoveAccountNameFromDomain(IN PSAM_DB_OBJECT DomainObject, IN LPCWSTR lpContainerName, IN LPCWSTR lpAccountName)
Definition: domain.c:57
SampCheckAccountNameInDomain
NTSTATUS SampCheckAccountNameInDomain(IN PSAM_DB_OBJECT DomainObject, IN LPCWSTR lpAccountName)
Definition: domain.c:96
SampCreateAccountSid
NTSTATUS SampCreateAccountSid(IN PSAM_DB_OBJECT DomainObject, IN ULONG ulRelativeId, IN OUT PSID *AccountSid)
Definition: domain.c:303
SampRemoveMemberFromAllAliases
NTSTATUS SampRemoveMemberFromAllAliases(IN PSAM_DB_OBJECT DomainObject, IN PRPC_SID MemberSid)
Definition: domain.c:214
SampRemoveMemberFromGroup
NTSTATUS SampRemoveMemberFromGroup(IN PSAM_DB_OBJECT GroupObject, IN ULONG MemberId)
Definition: group.c:103
SampAddMemberToGroup
NTSTATUS SampAddMemberToGroup(IN PSAM_DB_OBJECT GroupObject, IN ULONG MemberId)
Definition: group.c:39
SampRegQueryValue
NTSTATUS SampRegQueryValue(IN HANDLE KeyHandle, IN LPCWSTR ValueName, OUT PULONG Type OPTIONAL, OUT PVOID Data OPTIONAL, IN OUT PULONG DataLength OPTIONAL)
Definition: registry.c:332
SampRegCloseKey
NTSTATUS SampRegCloseKey(IN OUT PHANDLE KeyHandle)
Definition: registry.c:26
SampRegEnumerateValue
NTSTATUS SampRegEnumerateValue(IN HANDLE KeyHandle, IN ULONG Index, OUT LPWSTR Name, IN OUT PULONG NameLength, OUT PULONG Type OPTIONAL, OUT PVOID Data OPTIONAL, IN OUT PULONG DataLength OPTIONAL)
Definition: registry.c:226
SampRegQueryKeyInfo
NTSTATUS SampRegQueryKeyInfo(IN HANDLE KeyHandle, OUT PULONG SubKeyCount, OUT PULONG ValueCount)
Definition: registry.c:181
SampRegOpenKey
NTSTATUS SampRegOpenKey(IN HANDLE ParentKeyHandle, IN LPCWSTR KeyName, IN ACCESS_MASK DesiredAccess, OUT PHANDLE KeyHandle)
Definition: registry.c:158
SampRegEnumerateSubKey
NTSTATUS SampRegEnumerateSubKey(IN HANDLE KeyHandle, IN ULONG Index, IN ULONG Length, OUT LPWSTR Buffer)
Definition: registry.c:101
SampCreateGroupSD
NTSTATUS SampCreateGroupSD(OUT PSECURITY_DESCRIPTOR *GroupSd, OUT PULONG Size)
Definition: security.c:1146
SampRemoveUserFromAllGroups
NTSTATUS SampRemoveUserFromAllGroups(IN PSAM_DB_OBJECT UserObject)
Definition: user.c:319
SampCheckAccountName
NTSTATUS SampCheckAccountName(IN PRPC_UNICODE_STRING AccountName, IN USHORT MaxLength)
Definition: utils.c:154
SampCreateAliasSD
NTSTATUS SampCreateAliasSD(OUT PSECURITY_DESCRIPTOR *AliasSd, OUT PULONG Size)
Definition: security.c:859
SampCreateUserSD
NTSTATUS SampCreateUserSD(IN PSID UserSid, OUT PSECURITY_DESCRIPTOR *UserSd, OUT PULONG Size)
Definition: security.c:1433
SAM_GROUP_FIXED_DATA
struct _SAM_GROUP_FIXED_DATA SAM_GROUP_FIXED_DATA
SampRemoveGroupMembershipFromUser
NTSTATUS SampRemoveGroupMembershipFromUser(IN PSAM_DB_OBJECT UserObject, IN ULONG GroupId)
Definition: user.c:108
SampAddGroupMembershipToUser
NTSTATUS SampAddGroupMembershipToUser(IN PSAM_DB_OBJECT UserObject, IN ULONG GroupId, IN ULONG Attributes)
Definition: user.c:39
SAM_DOMAIN_FIXED_DATA
struct _SAM_DOMAIN_FIXED_DATA SAM_DOMAIN_FIXED_DATA
SampOpenUserObject
NTSTATUS SampOpenUserObject(IN PSAM_DB_OBJECT DomainObject, IN ULONG UserId, IN ACCESS_MASK DesiredAccess, OUT PSAM_DB_OBJECT *UserObject)
Definition: user.c:14
SampGetLogonHoursAttribute
NTSTATUS SampGetLogonHoursAttribute(IN PSAM_DB_OBJECT UserObject, IN OUT PSAMPR_LOGON_HOURS LogonHours)
Definition: user.c:810
SampGetUserGroupAttributes
NTSTATUS SampGetUserGroupAttributes(IN PSAM_DB_OBJECT DomainObject, IN ULONG UserId, IN ULONG GroupId, OUT PULONG GroupAttributes)
Definition: user.c:183
SampSetUserGroupAttributes
NTSTATUS SampSetUserGroupAttributes(IN PSAM_DB_OBJECT DomainObject, IN ULONG UserId, IN ULONG GroupId, IN ULONG GroupAttributes)
Definition: user.c:248
SAM_USER_FIXED_DATA
struct _SAM_USER_FIXED_DATA SAM_USER_FIXED_DATA
SampSetLogonHoursAttribute
NTSTATUS SampSetLogonHoursAttribute(IN PSAM_DB_OBJECT UserObject, IN PSAMPR_LOGON_HOURS LogonHours)
Definition: user.c:880
SampSetUserPassword
NTSTATUS SampSetUserPassword(IN PSAM_DB_OBJECT UserObject, IN PENCRYPTED_NT_OWF_PASSWORD NtPassword, IN BOOLEAN NtPasswordPresent, IN PENCRYPTED_LM_OWF_PASSWORD LmPassword, IN BOOLEAN LmPasswordPresent)
Definition: user.c:590
SampRemoveUserFromAllAliases
NTSTATUS SampRemoveUserFromAllAliases(IN PSAM_DB_OBJECT UserObject)
SamDbGroupObject
@ SamDbGroupObject
Definition: samsrv.h:41
SamDbUserObject
@ SamDbUserObject
Definition: samsrv.h:42
SamDbIgnoreObject
@ SamDbIgnoreObject
Definition: samsrv.h:37
SamDbAliasObject
@ SamDbAliasObject
Definition: samsrv.h:40
SamDbServerObject
@ SamDbServerObject
Definition: samsrv.h:38
SamDbDomainObject
@ SamDbDomainObject
Definition: samsrv.h:39
SampGetRidFromSid
NTSTATUS SampGetRidFromSid(IN PSID Sid, OUT PULONG Rid)
Definition: utils.c:138
L
#define L(x)
Definition: resources.c:13
Mapping
static PVOID Mapping[EMS_PHYSICAL_PAGES]
Definition: emsdrv.c:41
UNICODE_STRING
struct _UNICODE_STRING UNICODE_STRING
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
SecurityInformation
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ SECURITY_INFORMATION SecurityInformation
Definition: fltkernel.h:1340
Handle
ULONG Handle
Definition: gdb_input.c:15
Status
Status
Definition: gdiplustypes.h:24
len
GLenum GLsizei len
Definition: glext.h:6722
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
j
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
LocalFree
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
RtlEqualMemory
#define RtlEqualMemory(dst, src, len)
Definition: kdvm.h:18
Unused
#define Unused(x)
Definition: atlwin.h:28
SidTypeUnknown
@ SidTypeUnknown
Definition: lsa.idl:125
SidTypeAlias
@ SidTypeAlias
Definition: lsa.idl:121
SidTypeGroup
@ SidTypeGroup
Definition: lsa.idl:119
SidTypeUser
@ SidTypeUser
Definition: lsa.idl:118
memcpy
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
ptr
static PVOID ptr
Definition: dispmode.c:27
_swprintf
#define _swprintf(buf, format,...)
Definition: sprintf.c:56
SECURITY_INFORMATION
DWORD SECURITY_INFORMATION
Definition: ms-dtyp.idl:311
PENCRYPTED_NT_OWF_PASSWORD
struct _ENCRYPTED_LM_OWF_PASSWORD * PENCRYPTED_NT_OWF_PASSWORD
PENCRYPTED_LM_OWF_PASSWORD
struct _ENCRYPTED_LM_OWF_PASSWORD * PENCRYPTED_LM_OWF_PASSWORD
USER_LOGON_SUCCESS
#define USER_LOGON_SUCCESS
Definition: sam.idl:649
ENCRYPTED_NT_OWF_PASSWORD
struct _ENCRYPTED_LM_OWF_PASSWORD ENCRYPTED_NT_OWF_PASSWORD
ENCRYPTED_LM_OWF_PASSWORD
struct _ENCRYPTED_LM_OWF_PASSWORD ENCRYPTED_LM_OWF_PASSWORD
USER_LOGON_BAD_PASSWORD
#define USER_LOGON_BAD_PASSWORD
Definition: sam.idl:648
TokenHandle
_In_ ACCESS_MASK _In_ ULONG _Out_ PHANDLE TokenHandle
Definition: psfuncs.h:772
RtlSetSecurityObject
NTSYSAPI NTSTATUS NTAPI RtlSetSecurityObject(_In_ SECURITY_INFORMATION SecurityInformation, _In_ PSECURITY_DESCRIPTOR ModificationDescriptor, _Out_ PSECURITY_DESCRIPTOR *ObjectsSecurityDescriptor, _In_ PGENERIC_MAPPING GenericMapping, _In_ HANDLE Token)
RtlAcquireResourceShared
NTSYSAPI BOOLEAN NTAPI RtlAcquireResourceShared(_In_ PRTL_RESOURCE Resource, _In_ BOOLEAN Wait)
Owner
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID Owner
Definition: rtlfuncs.h:1629
Sid
_In_ ULONG _In_ ACCESS_MASK _In_ PSID Sid
Definition: rtlfuncs.h:1165
RtlMakeSelfRelativeSD
NTSYSAPI NTSTATUS NTAPI RtlMakeSelfRelativeSD(_In_ PSECURITY_DESCRIPTOR AbsoluteSD, _Out_ PSECURITY_DESCRIPTOR SelfRelativeSD, _Inout_ PULONG BufferLength)
RtlMapGenericMask
NTSYSAPI VOID NTAPI RtlMapGenericMask(PACCESS_MASK AccessMask, PGENERIC_MAPPING GenericMapping)
RtlAcquireResourceExclusive
NTSYSAPI BOOLEAN NTAPI RtlAcquireResourceExclusive(_In_ PRTL_RESOURCE Resource, _In_ BOOLEAN Wait)
RtlValidSecurityDescriptor
NTSYSAPI BOOLEAN NTAPI RtlValidSecurityDescriptor(IN PSECURITY_DESCRIPTOR SecurityDescriptor)
Definition: sd.c:1054
RtlReleaseResource
NTSYSAPI VOID NTAPI RtlReleaseResource(_In_ PRTL_RESOURCE Resource)
SE_GROUP_MANDATORY
#define SE_GROUP_MANDATORY
Definition: setypes.h:90
SE_GROUP_ENABLED_BY_DEFAULT
#define SE_GROUP_ENABLED_BY_DEFAULT
Definition: setypes.h:91
SE_GROUP_ENABLED
#define SE_GROUP_ENABLED
Definition: setypes.h:92
WRITE_DAC
#define WRITE_DAC
Definition: nt_native.h:59
REG_BINARY
#define REG_BINARY
Definition: nt_native.h:1499
ACCESS_SYSTEM_SECURITY
#define ACCESS_SYSTEM_SECURITY
Definition: nt_native.h:77
KEY_READ
#define KEY_READ
Definition: nt_native.h:1026
RtlInitUnicodeString
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
ACCESS_MASK
ULONG ACCESS_MASK
Definition: nt_native.h:40
RtlEqualUnicodeString
NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive)
NtClose
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3434
DELETE
#define DELETE
Definition: nt_native.h:57
READ_CONTROL
#define READ_CONTROL
Definition: nt_native.h:58
WRITE_OWNER
#define WRITE_OWNER
Definition: nt_native.h:60
DBG_UNREFERENCED_LOCAL_VARIABLE
#define DBG_UNREFERENCED_LOCAL_VARIABLE(L)
Definition: ntbasedef.h:331
UNICODE_NULL
#define UNICODE_NULL
MAXLONGLONG
#define MAXLONGLONG
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
NtQuerySystemTime
NTSTATUS NTAPI NtQuerySystemTime(OUT PLARGE_INTEGER SystemTime)
Definition: time.c:563
USER_READ_GENERAL
#define USER_READ_GENERAL
Definition: ntsam.h:126
SAM_SERVER_READ
#define SAM_SERVER_READ
Definition: ntsam.h:106
USER_READ
#define USER_READ
Definition: ntsam.h:138
DomainLogoffInformation
@ DomainLogoffInformation
Definition: ntsam.h:343
DomainReplicationInformation
@ DomainReplicationInformation
Definition: ntsam.h:346
DomainOemInformation
@ DomainOemInformation
Definition: ntsam.h:344
DomainNameInformation
@ DomainNameInformation
Definition: ntsam.h:345
DomainServerRoleInformation
@ DomainServerRoleInformation
Definition: ntsam.h:347
DomainPasswordInformation
@ DomainPasswordInformation
Definition: ntsam.h:341
DomainLockoutInformation
@ DomainLockoutInformation
Definition: ntsam.h:352
DomainModifiedInformation2
@ DomainModifiedInformation2
Definition: ntsam.h:353
DomainGeneralInformation
@ DomainGeneralInformation
Definition: ntsam.h:342
DomainGeneralInformation2
@ DomainGeneralInformation2
Definition: ntsam.h:351
DomainStateInformation
@ DomainStateInformation
Definition: ntsam.h:349
DomainModifiedInformation
@ DomainModifiedInformation
Definition: ntsam.h:348
USER_ALL_READ_GENERAL_MASK
#define USER_ALL_READ_GENERAL_MASK
Definition: ntsam.h:228
USER_READ_LOGON
#define USER_READ_LOGON
Definition: ntsam.h:129
USER_ALL_SCRIPTPATH
#define USER_ALL_SCRIPTPATH
Definition: ntsam.h:204
USER_ALL_COUNTRYCODE
#define USER_ALL_COUNTRYCODE
Definition: ntsam.h:218
GROUP_ALL_ACCESS
#define GROUP_ALL_ACCESS
Definition: ntsam.h:92
USER_NORMAL_ACCOUNT
#define USER_NORMAL_ACCOUNT
Definition: ntsam.h:171
USER_ALL_ADMINCOMMENT
#define USER_ALL_ADMINCOMMENT
Definition: ntsam.h:200
AliasGeneralInformation
@ AliasGeneralInformation
Definition: ntsam.h:279
AliasAdminCommentInformation
@ AliasAdminCommentInformation
Definition: ntsam.h:281
AliasNameInformation
@ AliasNameInformation
Definition: ntsam.h:280
USER_FORCE_PASSWORD_CHANGE
#define USER_FORCE_PASSWORD_CHANGE
Definition: ntsam.h:133
SAM_SERVER_EXECUTE
#define SAM_SERVER_EXECUTE
Definition: ntsam.h:114
DOMAIN_WRITE_OTHER_PARAMETERS
#define DOMAIN_WRITE_OTHER_PARAMETERS
Definition: ntsam.h:36
GROUP_READ_INFORMATION
#define GROUP_READ_INFORMATION
Definition: ntsam.h:75
USER_WRITE
#define USER_WRITE
Definition: ntsam.h:145
GROUP_ADD_MEMBER
#define GROUP_ADD_MEMBER
Definition: ntsam.h:77
GROUP_EXECUTE
#define GROUP_EXECUTE
Definition: ntsam.h:89
DOMAIN_ALL_ACCESS
#define DOMAIN_ALL_ACCESS
Definition: ntsam.h:62
SAM_SERVER_SHUTDOWN
#define SAM_SERVER_SHUTDOWN
Definition: ntsam.h:100
USER_EXECUTE
#define USER_EXECUTE
Definition: ntsam.h:149
DOMAIN_CREATE_GROUP
#define DOMAIN_CREATE_GROUP
Definition: ntsam.h:38
DOMAIN_LOOKUP
#define DOMAIN_LOOKUP
Definition: ntsam.h:42
USER_ALL_PARAMETERS
#define USER_ALL_PARAMETERS
Definition: ntsam.h:217
USER_ALL_WORKSTATIONS
#define USER_ALL_WORKSTATIONS
Definition: ntsam.h:206
USER_PASSWORD_NOT_REQUIRED
#define USER_PASSWORD_NOT_REQUIRED
Definition: ntsam.h:169
USER_READ_PREFERENCES
#define USER_READ_PREFERENCES
Definition: ntsam.h:127
GROUP_INFORMATION_CLASS
enum _GROUP_INFORMATION_CLASS GROUP_INFORMATION_CLASS
USER_ALL_READ_LOGON_MASK
#define USER_ALL_READ_LOGON_MASK
Definition: ntsam.h:229
USER_WRITE_ACCOUNT
#define USER_WRITE_ACCOUNT
Definition: ntsam.h:131
USER_ALL_USERID
#define USER_ALL_USERID
Definition: ntsam.h:198
USER_READ_ACCOUNT
#define USER_READ_ACCOUNT
Definition: ntsam.h:130
DOMAIN_DISPLAY_INFORMATION
enum _DOMAIN_DISPLAY_INFORMATION DOMAIN_DISPLAY_INFORMATION
DOMAIN_CREATE_ALIAS
#define DOMAIN_CREATE_ALIAS
Definition: ntsam.h:39
USER_WORKSTATION_TRUST_ACCOUNT
#define USER_WORKSTATION_TRUST_ACCOUNT
Definition: ntsam.h:174
USER_ALL_HOMEDIRECTORY
#define USER_ALL_HOMEDIRECTORY
Definition: ntsam.h:202
USER_ALL_USERNAME
#define USER_ALL_USERNAME
Definition: ntsam.h:196
USER_ALL_PASSWORDCANCHANGE
#define USER_ALL_PASSWORDCANCHANGE
Definition: ntsam.h:212
DOMAIN_EXECUTE
#define DOMAIN_EXECUTE
Definition: ntsam.h:57
USER_ALL_PRIVATEDATA
#define USER_ALL_PRIVATEDATA
Definition: ntsam.h:222
USER_ALL_LMPASSWORDPRESENT
#define USER_ALL_LMPASSWORDPRESENT
Definition: ntsam.h:221
USER_ALL_HOMEDIRECTORYDRIVE
#define USER_ALL_HOMEDIRECTORYDRIVE
Definition: ntsam.h:203
SAM_SERVER_LOOKUP_DOMAIN
#define SAM_SERVER_LOOKUP_DOMAIN
Definition: ntsam.h:104
ALIAS_EXECUTE
#define ALIAS_EXECUTE
Definition: ntsam.h:23
USER_ALL_PASSWORDEXPIRED
#define USER_ALL_PASSWORDEXPIRED
Definition: ntsam.h:223
USER_ALL_USERCOMMENT
#define USER_ALL_USERCOMMENT
Definition: ntsam.h:201
USER_ALL_ACCOUNTEXPIRES
#define USER_ALL_ACCOUNTEXPIRES
Definition: ntsam.h:215
ALIAS_WRITE_ACCOUNT
#define ALIAS_WRITE_ACCOUNT
Definition: ntsam.h:13
UserScriptInformation
@ UserScriptInformation
Definition: ntsam.h:524
UserAccountNameInformation
@ UserAccountNameInformation
Definition: ntsam.h:520
UserPrimaryGroupInformation
@ UserPrimaryGroupInformation
Definition: ntsam.h:522
UserAccountInformation
@ UserAccountInformation
Definition: ntsam.h:518
UserInternal1Information
@ UserInternal1Information
Definition: ntsam.h:531
UserParametersInformation
@ UserParametersInformation
Definition: ntsam.h:533
UserWorkStationsInformation
@ UserWorkStationsInformation
Definition: ntsam.h:527
UserNameInformation
@ UserNameInformation
Definition: ntsam.h:519
UserLogonHoursInformation
@ UserLogonHoursInformation
Definition: ntsam.h:517
UserLogonInformation
@ UserLogonInformation
Definition: ntsam.h:516
UserSetPasswordInformation
@ UserSetPasswordInformation
Definition: ntsam.h:528
UserGeneralInformation
@ UserGeneralInformation
Definition: ntsam.h:514
UserFullNameInformation
@ UserFullNameInformation
Definition: ntsam.h:521
UserInternal2Information
@ UserInternal2Information
Definition: ntsam.h:532
UserControlInformation
@ UserControlInformation
Definition: ntsam.h:529
UserAdminCommentInformation
@ UserAdminCommentInformation
Definition: ntsam.h:526
UserProfileInformation
@ UserProfileInformation
Definition: ntsam.h:525
UserAllInformation
@ UserAllInformation
Definition: ntsam.h:534
UserExpiresInformation
@ UserExpiresInformation
Definition: ntsam.h:530
UserPreferencesInformation
@ UserPreferencesInformation
Definition: ntsam.h:515
UserHomeInformation
@ UserHomeInformation
Definition: ntsam.h:523
USER_ALL_READ_PREFERENCES_MASK
#define USER_ALL_READ_PREFERENCES_MASK
Definition: ntsam.h:231
USER_ALL_READ_ACCOUNT_MASK
#define USER_ALL_READ_ACCOUNT_MASK
Definition: ntsam.h:230
USER_ALL_LASTLOGON
#define USER_ALL_LASTLOGON
Definition: ntsam.h:207
USER_ALL_LOGONHOURS
#define USER_ALL_LOGONHOURS
Definition: ntsam.h:209
ALIAS_LIST_MEMBERS
#define ALIAS_LIST_MEMBERS
Definition: ntsam.h:11
DOMAIN_WRITE_PASSWORD_PARAMS
#define DOMAIN_WRITE_PASSWORD_PARAMS
Definition: ntsam.h:34
USER_LIST_GROUPS
#define USER_LIST_GROUPS
Definition: ntsam.h:134
GROUP_LIST_MEMBERS
#define GROUP_LIST_MEMBERS
Definition: ntsam.h:79
GROUP_MEMBERSHIP
struct _GROUP_MEMBERSHIP GROUP_MEMBERSHIP
USER_ALL_PASSWORDLASTSET
#define USER_ALL_PASSWORDLASTSET
Definition: ntsam.h:214
ALIAS_READ_INFORMATION
#define ALIAS_READ_INFORMATION
Definition: ntsam.h:12
USER_TEMP_DUPLICATE_ACCOUNT
#define USER_TEMP_DUPLICATE_ACCOUNT
Definition: ntsam.h:170
ALIAS_READ
#define ALIAS_READ
Definition: ntsam.h:15
USER_WRITE_PREFERENCES
#define USER_WRITE_PREFERENCES
Definition: ntsam.h:128
SAM_SERVER_ENUMERATE_DOMAINS
#define SAM_SERVER_ENUMERATE_DOMAINS
Definition: ntsam.h:103
USER_ALL_PASSWORDMUSTCHANGE
#define USER_ALL_PASSWORDMUSTCHANGE
Definition: ntsam.h:213
GROUP_WRITE
#define GROUP_WRITE
Definition: ntsam.h:84
USER_ALL_PRIMARYGROUPID
#define USER_ALL_PRIMARYGROUPID
Definition: ntsam.h:199
USER_ALL_USERACCOUNTCONTROL
#define USER_ALL_USERACCOUNTCONTROL
Definition: ntsam.h:216
DOMAIN_READ_PASSWORD_PARAMETERS
#define DOMAIN_READ_PASSWORD_PARAMETERS
Definition: ntsam.h:33
USER_ALL_ACCESS
#define USER_ALL_ACCESS
Definition: ntsam.h:153
GROUP_WRITE_ACCOUNT
#define GROUP_WRITE_ACCOUNT
Definition: ntsam.h:76
DOMAIN_WRITE
#define DOMAIN_WRITE
Definition: ntsam.h:49
USER_ALL_FULLNAME
#define USER_ALL_FULLNAME
Definition: ntsam.h:197
GROUP_REMOVE_MEMBER
#define GROUP_REMOVE_MEMBER
Definition: ntsam.h:78
USER_ALL_LASTLOGOFF
#define USER_ALL_LASTLOGOFF
Definition: ntsam.h:208
USER_CHANGE_PASSWORD
#define USER_CHANGE_PASSWORD
Definition: ntsam.h:132
ALIAS_REMOVE_MEMBER
#define ALIAS_REMOVE_MEMBER
Definition: ntsam.h:10
DOMAIN_CREATE_USER
#define DOMAIN_CREATE_USER
Definition: ntsam.h:37
USER_ALL_CODEPAGE
#define USER_ALL_CODEPAGE
Definition: ntsam.h:219
USER_ALL_BADPASSWORDCOUNT
#define USER_ALL_BADPASSWORDCOUNT
Definition: ntsam.h:210
USER_ALL_SECURITYDESCRIPTOR
#define USER_ALL_SECURITYDESCRIPTOR
Definition: ntsam.h:224
USER_ALL_LOGONCOUNT
#define USER_ALL_LOGONCOUNT
Definition: ntsam.h:211
DOMAIN_READ
#define DOMAIN_READ
Definition: ntsam.h:45
DOMAIN_GET_ALIAS_MEMBERSHIP
#define DOMAIN_GET_ALIAS_MEMBERSHIP
Definition: ntsam.h:40
SAM_SERVER_ALL_ACCESS
#define SAM_SERVER_ALL_ACCESS
Definition: ntsam.h:118
USER_ALL_PROFILEPATH
#define USER_ALL_PROFILEPATH
Definition: ntsam.h:205
USER_ALL_NTPASSWORDPRESENT
#define USER_ALL_NTPASSWORDPRESENT
Definition: ntsam.h:220
DOMAIN_LIST_ACCOUNTS
#define DOMAIN_LIST_ACCOUNTS
Definition: ntsam.h:41
USER_SERVER_TRUST_ACCOUNT
#define USER_SERVER_TRUST_ACCOUNT
Definition: ntsam.h:175
DOMAIN_ADMINISTER_SERVER
#define DOMAIN_ADMINISTER_SERVER
Definition: ntsam.h:43
GROUP_READ
#define GROUP_READ
Definition: ntsam.h:81
ALIAS_WRITE
#define ALIAS_WRITE
Definition: ntsam.h:18
SAM_SERVER_WRITE
#define SAM_SERVER_WRITE
Definition: ntsam.h:109
DOMAIN_INFORMATION_CLASS
enum _DOMAIN_INFORMATION_CLASS DOMAIN_INFORMATION_CLASS
ALIAS_INFORMATION_CLASS
enum _ALIAS_INFORMATION_CLASS ALIAS_INFORMATION_CLASS
USER_INTERDOMAIN_TRUST_ACCOUNT
#define USER_INTERDOMAIN_TRUST_ACCOUNT
Definition: ntsam.h:173
USER_ACCOUNT_DISABLED
#define USER_ACCOUNT_DISABLED
Definition: ntsam.h:167
ALIAS_ALL_ACCESS
#define ALIAS_ALL_ACCESS
Definition: ntsam.h:26
USER_INFORMATION_CLASS
enum _USER_INFORMATION_CLASS USER_INFORMATION_CLASS
USER_ALL_READ_TRUSTED_MASK
#define USER_ALL_READ_TRUSTED_MASK
Definition: ntsam.h:232
ALIAS_ADD_MEMBER
#define ALIAS_ADD_MEMBER
Definition: ntsam.h:9
DOMAIN_READ_OTHER_PARAMETERS
#define DOMAIN_READ_OTHER_PARAMETERS
Definition: ntsam.h:35
GroupAttributeInformation
@ GroupAttributeInformation
Definition: ntsam.h:466
GroupGeneralInformation
@ GroupGeneralInformation
Definition: ntsam.h:464
GroupNameInformation
@ GroupNameInformation
Definition: ntsam.h:465
GroupAdminCommentInformation
@ GroupAdminCommentInformation
Definition: ntsam.h:467
STATUS_WRONG_PASSWORD
#define STATUS_WRONG_PASSWORD
Definition: ntstatus.h:436
STATUS_MEMBER_IN_ALIAS
#define STATUS_MEMBER_IN_ALIAS
Definition: ntstatus.h:669
STATUS_NONE_MAPPED
#define STATUS_NONE_MAPPED
Definition: ntstatus.h:445
STATUS_NO_SUCH_DOMAIN
#define STATUS_NO_SUCH_DOMAIN
Definition: ntstatus.h:553
STATUS_SOME_NOT_MAPPED
#define STATUS_SOME_NOT_MAPPED
Definition: ntstatus.h:139
STATUS_MEMBER_IN_GROUP
#define STATUS_MEMBER_IN_GROUP
Definition: ntstatus.h:433
STATUS_NO_MORE_ENTRIES
#define STATUS_NO_MORE_ENTRIES
Definition: ntstatus.h:285
STATUS_SPECIAL_ACCOUNT
#define STATUS_SPECIAL_ACCOUNT
Definition: ntstatus.h:622
STATUS_INVALID_INFO_CLASS
#define STATUS_INVALID_INFO_CLASS
Definition: ntstatus.h:333
STATUS_ACCOUNT_RESTRICTION
#define STATUS_ACCOUNT_RESTRICTION
Definition: ntstatus.h:440
PBYTE
BYTE * PBYTE
Definition: pedump.c:66
WCHAR
short WCHAR
Definition: pedump.c:58
USHORT
unsigned short USHORT
Definition: pedump.c:61
NameLength
Input NameLength
Definition: portacpi.cpp:298
RpcServerListen
RPC_STATUS WINAPI RpcServerListen(UINT MinimumCallThreads, UINT MaxCalls, UINT DontWait)
Definition: rpc_server.c:1520
RpcServerRegisterIf
RPC_STATUS WINAPI RpcServerRegisterIf(RPC_IF_HANDLE IfSpec, UUID *MgrTypeUuid, RPC_MGR_EPV *MgrEpv)
Definition: rpc_server.c:1116
RpcServerUseProtseqEpW
RPC_STATUS WINAPI RpcServerUseProtseqEpW(RPC_WSTR Protseq, UINT MaxCalls, RPC_WSTR Endpoint, LPVOID SecurityDescriptor)
Definition: rpc_server.c:927
RpcMgmtStopServerListening
RPC_STATUS WINAPI RpcMgmtStopServerListening(RPC_BINDING_HANDLE Binding)
Definition: rpc_server.c:1596
RPC_C_PROTSEQ_MAX_REQS_DEFAULT
#define RPC_C_PROTSEQ_MAX_REQS_DEFAULT
Definition: rpcdce.h:123
RPC_S_OK
#define RPC_S_OK
Definition: rpcnterr.h:22
PASSWORD_POLICY_VALIDATION_TYPE
enum _PASSWORD_POLICY_VALIDATION_TYPE PASSWORD_POLICY_VALIDATION_TYPE
SAMPR_REVISION_INFO
union @4363 SAMPR_REVISION_INFO
SamrCreateAliasInDomain
NTSTATUS NTAPI SamrCreateAliasInDomain(IN SAMPR_HANDLE DomainHandle, IN PRPC_UNICODE_STRING AccountName, IN ACCESS_MASK DesiredAccess, OUT SAMPR_HANDLE *AliasHandle, OUT unsigned long *RelativeId)
Definition: samrpc.c:2913
SampQueryDomainReplication
static NTSTATUS SampQueryDomainReplication(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:1241
SamrEnumerateGroupsInDomain
NTSTATUS NTAPI SamrEnumerateGroupsInDomain(IN SAMPR_HANDLE DomainHandle, IN OUT unsigned long *EnumerationContext, OUT PSAMPR_ENUMERATION_BUFFER *Buffer, IN unsigned long PreferedMaximumLength, OUT unsigned long *CountReturned)
Definition: samrpc.c:2092
SampSetUserName
static NTSTATUS SampSetUserName(PSAM_DB_OBJECT UserObject, PRPC_UNICODE_STRING NewUserName)
Definition: samrpc.c:7252
SampQueryUserLogon
static NTSTATUS SampQueryUserLogon(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:5701
SamrQueryInformationAlias
NTSTATUS NTAPI SamrQueryInformationAlias(IN SAMPR_HANDLE AliasHandle, IN ALIAS_INFORMATION_CLASS AliasInformationClass, OUT PSAMPR_ALIAS_INFO_BUFFER *Buffer)
Definition: samrpc.c:5048
SampSetUserPreferences
static NTSTATUS SampSetUserPreferences(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER Buffer)
Definition: samrpc.c:7376
SamrGetMembersInAlias
NTSTATUS NTAPI SamrGetMembersInAlias(IN SAMPR_HANDLE AliasHandle, OUT PSAMPR_PSID_ARRAY_OUT Members)
Definition: samrpc.c:5364
SamrSetBootKeyInformation
NTSTATUS NTAPI SamrSetBootKeyInformation(IN handle_t BindingHandle)
Definition: samrpc.c:9677
SamrQueryInformationDomain2
NTSTATUS NTAPI SamrQueryInformationDomain2(IN SAMPR_HANDLE DomainHandle, IN DOMAIN_INFORMATION_CLASS DomainInformationClass, OUT PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:8465
NtSidAuthority
static SID_IDENTIFIER_AUTHORITY NtSidAuthority
Definition: samrpc.c:14
SamrShutdownSamServer
NTSTATUS NTAPI SamrShutdownSamServer(IN SAMPR_HANDLE ServerHandle)
Definition: samrpc.c:466
SamrUnicodeChangePasswordUser2
NTSTATUS NTAPI SamrUnicodeChangePasswordUser2(IN handle_t BindingHandle, IN PRPC_UNICODE_STRING ServerName, IN PRPC_UNICODE_STRING UserName, IN PSAMPR_ENCRYPTED_USER_PASSWORD NewPasswordEncryptedWithOldNt, IN PENCRYPTED_NT_OWF_PASSWORD OldNtOwfPasswordEncryptedWithNewNt, IN unsigned char LmPresent, IN PSAMPR_ENCRYPTED_USER_PASSWORD NewPasswordEncryptedWithOldLm, IN PENCRYPTED_LM_OWF_PASSWORD OldLmOwfPasswordEncryptedWithNewNt)
Definition: samrpc.c:9365
SamrEnumerateAliasesInDomain
NTSTATUS NTAPI SamrEnumerateAliasesInDomain(IN SAMPR_HANDLE DomainHandle, IN OUT unsigned long *EnumerationContext, OUT PSAMPR_ENUMERATION_BUFFER *Buffer, IN unsigned long PreferedMaximumLength, OUT unsigned long *CountReturned)
Definition: samrpc.c:3089
SamrSetInformationUser
NTSTATUS NTAPI SamrSetInformationUser(IN SAMPR_HANDLE UserHandle, IN USER_INFORMATION_CLASS UserInformationClass, IN PSAMPR_USER_INFO_BUFFER Buffer)
Definition: samrpc.c:7852
SampQueryUserAdminComment
static NTSTATUS SampQueryUserAdminComment(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6409
SamrSetInformationGroup
NTSTATUS NTAPI SamrSetInformationGroup(IN SAMPR_HANDLE GroupHandle, IN GROUP_INFORMATION_CLASS GroupInformationClass, IN PSAMPR_GROUP_INFO_BUFFER Buffer)
Definition: samrpc.c:4420
SamrGetUserDomainPasswordInformation
NTSTATUS NTAPI SamrGetUserDomainPasswordInformation(IN SAMPR_HANDLE UserHandle, OUT PUSER_DOMAIN_PASSWORD_INFORMATION PasswordInformation)
Definition: samrpc.c:8318
SampQueryUserWorkStations
static NTSTATUS SampQueryUserWorkStations(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6450
SamrConnect3
NTSTATUS NTAPI SamrConnect3(IN handle_t BindingHandle)
Definition: samrpc.c:9695
SampQueryUserInternal2
static NTSTATUS SampQueryUserInternal2(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6665
SamrTestPrivateFunctionsDomain
NTSTATUS NTAPI SamrTestPrivateFunctionsDomain(IN SAMPR_HANDLE DomainHandle)
Definition: samrpc.c:8298
SamrQueryDisplayInformation2
NTSTATUS NTAPI SamrQueryDisplayInformation2(IN SAMPR_HANDLE DomainHandle, IN DOMAIN_DISPLAY_INFORMATION DisplayInformationClass, IN unsigned long Index, IN unsigned long EntryCount, IN unsigned long PreferredMaximumLength, OUT unsigned long *TotalAvailable, OUT unsigned long *TotalReturned, OUT PSAMPR_DISPLAY_INFO_BUFFER Buffer)
Definition: samrpc.c:8785
SamrChangePasswordUser
NTSTATUS NTAPI SamrChangePasswordUser(IN SAMPR_HANDLE UserHandle, IN unsigned char LmPresent, IN PENCRYPTED_LM_OWF_PASSWORD OldLmEncryptedWithNewLm, IN PENCRYPTED_LM_OWF_PASSWORD NewLmEncryptedWithOldLm, IN unsigned char NtPresent, IN PENCRYPTED_NT_OWF_PASSWORD OldNtEncryptedWithNewNt, IN PENCRYPTED_NT_OWF_PASSWORD NewNtEncryptedWithOldNt, IN unsigned char NtCrossEncryptionPresent, IN PENCRYPTED_NT_OWF_PASSWORD NewNtEncryptedWithNewLm, IN unsigned char LmCrossEncryptionPresent, IN PENCRYPTED_LM_OWF_PASSWORD NewLmEncryptedWithNewNt)
Definition: samrpc.c:7868
SamrQuerySecurityObject
NTSTATUS NTAPI SamrQuerySecurityObject(IN SAMPR_HANDLE ObjectHandle, IN SECURITY_INFORMATION SecurityInformation, OUT PSAMPR_SR_SECURITY_DESCRIPTOR *SecurityDescriptor)
Definition: samrpc.c:329
SampSetDomainState
static NTSTATUS SampSetDomainState(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER Buffer)
Definition: samrpc.c:1730
SampQueryDomainLockout
static NTSTATUS SampQueryDomainLockout(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:1528
SampQueryDomainModified
static NTSTATUS SampQueryDomainModified(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:1323
SamrOpenAlias
NTSTATUS NTAPI SamrOpenAlias(IN SAMPR_HANDLE DomainHandle, IN ACCESS_MASK DesiredAccess, IN ULONG AliasId, OUT SAMPR_HANDLE *AliasHandle)
Definition: samrpc.c:4825
SamrTestPrivateFunctionsUser
NTSTATUS NTAPI SamrTestPrivateFunctionsUser(IN SAMPR_HANDLE UserHandle)
Definition: samrpc.c:8308
SamrDeleteUser
NTSTATUS NTAPI SamrDeleteUser(IN OUT SAMPR_HANDLE *UserHandle)
Definition: samrpc.c:5486
SampGetNumberOfAccounts
static NTSTATUS SampGetNumberOfAccounts(PSAM_DB_OBJECT DomainObject, LPCWSTR AccountType, PULONG Count)
Definition: samrpc.c:964
SampQueryDomainOem
static NTSTATUS SampQueryDomainOem(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:1159
SampQueryUserAll
static NTSTATUS SampQueryUserAll(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6753
SamrSetInformationAlias
NTSTATUS NTAPI SamrSetInformationAlias(IN SAMPR_HANDLE AliasHandle, IN ALIAS_INFORMATION_CLASS AliasInformationClass, IN PSAMPR_ALIAS_INFO_BUFFER Buffer)
Definition: samrpc.c:5177
SampQueryUserExpires
static NTSTATUS SampQueryUserExpires(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6534
SamrGetBootKeyInformation
NTSTATUS NTAPI SamrGetBootKeyInformation(IN handle_t BindingHandle)
Definition: samrpc.c:9686
SampSetUserAll
static NTSTATUS SampSetUserAll(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER Buffer)
Definition: samrpc.c:7612
SamrAddMultipleMembersToAlias
NTSTATUS NTAPI SamrAddMultipleMembersToAlias(IN SAMPR_HANDLE AliasHandle, IN PSAMPR_PSID_ARRAY MembersBuffer)
Definition: samrpc.c:9296
SamrAddMemberToAlias
NTSTATUS NTAPI SamrAddMemberToAlias(IN SAMPR_HANDLE AliasHandle, IN PRPC_SID MemberId)
Definition: samrpc.c:5284
SamrLookupDomainInSamServer
NTSTATUS NTAPI SamrLookupDomainInSamServer(IN SAMPR_HANDLE ServerHandle, IN PRPC_UNICODE_STRING Name, OUT PRPC_SID *DomainId)
Definition: samrpc.c:504
SamrGetMembersInGroup
NTSTATUS NTAPI SamrGetMembersInGroup(IN SAMPR_HANDLE GroupHandle, OUT PSAMPR_GET_MEMBERS_BUFFER *Members)
Definition: samrpc.c:4668
SampQueryUserGeneral
static NTSTATUS SampQueryUserGeneral(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:5551
SamrEnumerateUsersInDomain
NTSTATUS NTAPI SamrEnumerateUsersInDomain(IN SAMPR_HANDLE DomainHandle, IN OUT unsigned long *EnumerationContext, IN unsigned long UserAccountControl, OUT PSAMPR_ENUMERATION_BUFFER *Buffer, IN unsigned long PreferedMaximumLength, OUT unsigned long *CountReturned)
Definition: samrpc.c:2704
SampQueryUserPreferences
static NTSTATUS SampQueryUserPreferences(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:5645
SampQueryUserLogonHours
static NTSTATUS SampQueryUserLogonHours(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6050
SampSetDomainServerRole
static NTSTATUS SampSetDomainServerRole(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER Buffer)
Definition: samrpc.c:1700
SamrEnumerateDomainsInSamServer
NTSTATUS NTAPI SamrEnumerateDomainsInSamServer(IN SAMPR_HANDLE ServerHandle, IN OUT unsigned long *EnumerationContext, OUT PSAMPR_ENUMERATION_BUFFER *Buffer, IN ULONG PreferedMaximumLength, OUT PULONG CountReturned)
Definition: samrpc.c:621
SamrQueryInformationGroup
NTSTATUS NTAPI SamrQueryInformationGroup(IN SAMPR_HANDLE GroupHandle, IN GROUP_INFORMATION_CLASS GroupInformationClass, OUT PSAMPR_GROUP_INFO_BUFFER *Buffer)
Definition: samrpc.c:4256
SamrCreateGroupInDomain
NTSTATUS NTAPI SamrCreateGroupInDomain(IN SAMPR_HANDLE DomainHandle, IN PRPC_UNICODE_STRING Name, IN ACCESS_MASK DesiredAccess, OUT SAMPR_HANDLE *GroupHandle, OUT unsigned long *RelativeId)
Definition: samrpc.c:1898
SampQueryAliasGeneral
static NTSTATUS SampQueryAliasGeneral(PSAM_DB_OBJECT AliasObject, PSAMPR_ALIAS_INFO_BUFFER *Buffer)
Definition: samrpc.c:4883
SamrGetDisplayEnumerationIndex
NTSTATUS NTAPI SamrGetDisplayEnumerationIndex(IN SAMPR_HANDLE DomainHandle, IN DOMAIN_DISPLAY_INFORMATION DisplayInformationClass, IN PRPC_UNICODE_STRING Prefix, OUT unsigned long *Index)
Definition: samrpc.c:8280
SamrCreateUserInDomain
NTSTATUS NTAPI SamrCreateUserInDomain(IN SAMPR_HANDLE DomainHandle, IN PRPC_UNICODE_STRING Name, IN ACCESS_MASK DesiredAccess, OUT SAMPR_HANDLE *UserHandle, OUT unsigned long *RelativeId)
Definition: samrpc.c:2300
SampSetGroupAttribute
static NTSTATUS SampSetGroupAttribute(PSAM_DB_OBJECT GroupObject, PSAMPR_GROUP_INFO_BUFFER Buffer)
Definition: samrpc.c:4388
GroupMapping
static GENERIC_MAPPING GroupMapping
Definition: samrpc.c:40
SampAddRelativeTimeToTime
static LARGE_INTEGER SampAddRelativeTimeToTime(IN LARGE_INTEGER AbsoluteTime, IN LARGE_INTEGER RelativeTime)
Definition: samrpc.c:63
SampQueryGroupGeneral
static NTSTATUS SampQueryGroupGeneral(PSAM_DB_OBJECT GroupObject, PSAMPR_GROUP_INFO_BUFFER *Buffer)
Definition: samrpc.c:4040
SAMPR_HANDLE_rundown
void __RPC_USER SAMPR_HANDLE_rundown(SAMPR_HANDLE hHandle)
Definition: samrpc.c:126
UserMapping
static GENERIC_MAPPING UserMapping
Definition: samrpc.c:48
SampQueryUserControl
static NTSTATUS SampQueryUserControl(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6492
SamrOemChangePasswordUser2
NTSTATUS NTAPI SamrOemChangePasswordUser2(IN handle_t BindingHandle, IN PRPC_STRING ServerName, IN PRPC_STRING UserName, IN PSAMPR_ENCRYPTED_USER_PASSWORD NewPasswordEncryptedWithOldLm, IN PENCRYPTED_LM_OWF_PASSWORD OldLmOwfPasswordEncryptedWithNewLm)
Definition: samrpc.c:9352
SamrGetDomainPasswordInformation
NTSTATUS NTAPI SamrGetDomainPasswordInformation(IN handle_t BindingHandle, IN PRPC_UNICODE_STRING Unused, OUT PUSER_DOMAIN_PASSWORD_INFORMATION PasswordInformation)
Definition: samrpc.c:9382
SamrSetInformationUser2
NTSTATUS NTAPI SamrSetInformationUser2(IN SAMPR_HANDLE UserHandle, IN USER_INFORMATION_CLASS UserInformationClass, IN PSAMPR_USER_INFO_BUFFER Buffer)
Definition: samrpc.c:9472
SampQueryDomainName
static NTSTATUS SampQueryDomainName(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:1200
SampSetDomainLogoff
static NTSTATUS SampSetDomainLogoff(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER Buffer)
Definition: samrpc.c:1669
SampQueryDomainLogoff
static NTSTATUS SampQueryDomainLogoff(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:1117
SampQueryUserHome
static NTSTATUS SampQueryUserHome(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6273
SampQueryUserInternal1
static NTSTATUS SampQueryUserInternal1(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6577
SamrUnicodeChangePasswordUser3
NTSTATUS NTAPI SamrUnicodeChangePasswordUser3(IN handle_t BindingHandle)
Definition: samrpc.c:9732
SampQueryDomainPassword
static NTSTATUS SampQueryDomainPassword(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:917
SampQueryGroupName
static NTSTATUS SampQueryGroupName(PSAM_DB_OBJECT GroupObject, PSAMPR_GROUP_INFO_BUFFER *Buffer)
Definition: samrpc.c:4130
SamrRemoveMemberFromGroup
NTSTATUS NTAPI SamrRemoveMemberFromGroup(IN SAMPR_HANDLE GroupHandle, IN unsigned long MemberId)
Definition: samrpc.c:4606
SampSetDomainPassword
static NTSTATUS SampSetDomainPassword(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER Buffer)
Definition: samrpc.c:1633
SampQueryUserParameters
static NTSTATUS SampQueryUserParameters(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6712
SamrLookupIdsInDomain
NTSTATUS NTAPI SamrLookupIdsInDomain(IN SAMPR_HANDLE DomainHandle, IN ULONG Count, IN ULONG *RelativeIds, OUT PSAMPR_RETURNED_USTRING_ARRAY Names, OUT PSAMPR_ULONG_ARRAY Use)
Definition: samrpc.c:3697
SamrQueryDisplayInformation
NTSTATUS NTAPI SamrQueryDisplayInformation(IN SAMPR_HANDLE DomainHandle, IN DOMAIN_DISPLAY_INFORMATION DisplayInformationClass, IN unsigned long Index, IN unsigned long EntryCount, IN unsigned long PreferredMaximumLength, OUT unsigned long *TotalAvailable, OUT unsigned long *TotalReturned, OUT PSAMPR_DISPLAY_INFO_BUFFER Buffer)
Definition: samrpc.c:8252
SamrOpenGroup
NTSTATUS NTAPI SamrOpenGroup(IN SAMPR_HANDLE DomainHandle, IN ACCESS_MASK DesiredAccess, IN unsigned long GroupId, OUT SAMPR_HANDLE *GroupHandle)
Definition: samrpc.c:3982
SampSetDomainLockout
static NTSTATUS SampSetDomainLockout(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER Buffer)
Definition: samrpc.c:1760
SampQueryUserFullName
static NTSTATUS SampQueryUserFullName(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6190
SamrRemoveMemberFromAlias
NTSTATUS NTAPI SamrRemoveMemberFromAlias(IN SAMPR_HANDLE AliasHandle, IN PRPC_SID MemberId)
Definition: samrpc.c:5324
SampSetUserInternal2
static NTSTATUS SampSetUserInternal2(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER Buffer)
Definition: samrpc.c:7559
SamrGetAliasMembership
NTSTATUS NTAPI SamrGetAliasMembership(IN SAMPR_HANDLE DomainHandle, IN PSAMPR_PSID_ARRAY SidArray, OUT PSAMPR_ULONG_ARRAY Membership)
Definition: samrpc.c:3297
SamrQueryInformationDomain
NTSTATUS NTAPI SamrQueryInformationDomain(IN SAMPR_HANDLE DomainHandle, IN DOMAIN_INFORMATION_CLASS DomainInformationClass, OUT PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:1619
SampQueryAliasName
static NTSTATUS SampQueryAliasName(PSAM_DB_OBJECT AliasObject, PSAMPR_ALIAS_INFO_BUFFER *Buffer)
Definition: samrpc.c:4966
SampQueryUserPrimaryGroup
static NTSTATUS SampQueryUserPrimaryGroup(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6232
SamrRemoveMemberFromForeignDomain
NTSTATUS NTAPI SamrRemoveMemberFromForeignDomain(IN SAMPR_HANDLE DomainHandle, IN PRPC_SID MemberSid)
Definition: samrpc.c:8406
SamrQueryInformationUser2
NTSTATUS NTAPI SamrQueryInformationUser2(IN SAMPR_HANDLE UserHandle, IN USER_INFORMATION_CLASS UserInformationClass, OUT PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:8591
SamrDeleteGroup
NTSTATUS NTAPI SamrDeleteGroup(IN OUT SAMPR_HANDLE *GroupHandle)
Definition: samrpc.c:4538
SamrLookupNamesInDomain
NTSTATUS NTAPI SamrLookupNamesInDomain(IN SAMPR_HANDLE DomainHandle, IN ULONG Count, IN RPC_UNICODE_STRING Names[], OUT PSAMPR_ULONG_ARRAY RelativeIds, OUT PSAMPR_ULONG_ARRAY Use)
Definition: samrpc.c:3468
SampQueryUserName
static NTSTATUS SampQueryUserName(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6095
SamrOpenDomain
NTSTATUS NTAPI SamrOpenDomain(IN SAMPR_HANDLE ServerHandle, IN ACCESS_MASK DesiredAccess, IN PRPC_SID DomainId, OUT SAMPR_HANDLE *DomainHandle)
Definition: samrpc.c:831
SampQueryGroupAttribute
static NTSTATUS SampQueryGroupAttribute(PSAM_DB_OBJECT GroupObject, PSAMPR_GROUP_INFO_BUFFER *Buffer)
Definition: samrpc.c:4170
AliasMapping
static GENERIC_MAPPING AliasMapping
Definition: samrpc.c:32
DomainMapping
static GENERIC_MAPPING DomainMapping
Definition: samrpc.c:24
SampQueryDomainModified2
static NTSTATUS SampQueryDomainModified2(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:1571
SamrSetMemberAttributesOfGroup
NTSTATUS NTAPI SamrSetMemberAttributesOfGroup(IN SAMPR_HANDLE GroupHandle, IN unsigned long MemberId, IN unsigned long Attributes)
Definition: samrpc.c:4782
SamrCloseHandle
NTSTATUS NTAPI SamrCloseHandle(IN OUT SAMPR_HANDLE *SamHandle)
Definition: samrpc.c:161
SamrSetDSRMPassword
NTSTATUS NTAPI SamrSetDSRMPassword(IN handle_t BindingHandle, IN PRPC_UNICODE_STRING Unused, IN unsigned long UserId, IN PENCRYPTED_NT_OWF_PASSWORD EncryptedNtOwfPassword)
Definition: samrpc.c:9807
SamrConnect4
NTSTATUS NTAPI SamrConnect4(IN PSAMPR_SERVER_NAME ServerName, OUT SAMPR_HANDLE *ServerHandle, IN unsigned long ClientRevision, IN ACCESS_MASK DesiredAccess)
Definition: samrpc.c:9705
SampQueryUserAccount
static NTSTATUS SampQueryUserAccount(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:5880
SamrOpenUser
NTSTATUS NTAPI SamrOpenUser(IN SAMPR_HANDLE DomainHandle, IN ACCESS_MASK DesiredAccess, IN unsigned long UserId, OUT SAMPR_HANDLE *UserHandle)
Definition: samrpc.c:5426
SampQueryUserProfile
static NTSTATUS SampQueryUserProfile(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6368
SamrQueryDisplayInformation3
NTSTATUS NTAPI SamrQueryDisplayInformation3(IN SAMPR_HANDLE DomainHandle, IN DOMAIN_DISPLAY_INFORMATION DisplayInformationClass, IN unsigned long Index, IN unsigned long EntryCount, IN unsigned long PreferredMaximumLength, OUT unsigned long *TotalAvailable, OUT unsigned long *TotalReturned, OUT PSAMPR_DISPLAY_INFO_BUFFER Buffer)
Definition: samrpc.c:9244
SampQueryGroupAdminComment
static NTSTATUS SampQueryGroupAdminComment(PSAM_DB_OBJECT GroupObject, PSAMPR_GROUP_INFO_BUFFER *Buffer)
Definition: samrpc.c:4214
SampQueryDomainState
static NTSTATUS SampQueryDomainState(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:1367
SamrGetDisplayEnumerationIndex2
NTSTATUS NTAPI SamrGetDisplayEnumerationIndex2(IN SAMPR_HANDLE DomainHandle, IN DOMAIN_DISPLAY_INFORMATION DisplayInformationClass, IN PRPC_UNICODE_STRING Prefix, OUT unsigned long *Index)
Definition: samrpc.c:8813
SampQueryAliasAdminComment
static NTSTATUS SampQueryAliasAdminComment(PSAM_DB_OBJECT AliasObject, PSAMPR_ALIAS_INFO_BUFFER *Buffer)
Definition: samrpc.c:5006
SamrRidToSid
NTSTATUS NTAPI SamrRidToSid(IN SAMPR_HANDLE ObjectHandle, IN unsigned long Rid, OUT PRPC_SID *Sid)
Definition: samrpc.c:9796
SampQueryUserScript
static NTSTATUS SampQueryUserScript(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6327
SampSetUserExpires
static NTSTATUS SampSetUserExpires(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER Buffer)
Definition: samrpc.c:7473
SamrGetGroupsForUser
NTSTATUS NTAPI SamrGetGroupsForUser(IN SAMPR_HANDLE UserHandle, OUT PSAMPR_GET_GROUPS_BUFFER *Groups)
Definition: samrpc.c:8149
SampStartRpcServer
VOID SampStartRpcServer(VOID)
Definition: samrpc.c:78
SamrConnect5
NTSTATUS NTAPI SamrConnect5(IN PSAMPR_SERVER_NAME ServerName, IN ACCESS_MASK DesiredAccess, IN unsigned long InVersion, IN SAMPR_REVISION_INFO *InRevisionInfo, OUT unsigned long *OutVersion, OUT SAMPR_REVISION_INFO *OutRevisionInfo, OUT SAMPR_HANDLE *ServerHandle)
Definition: samrpc.c:9742
SampSetUserGeneral
static NTSTATUS SampSetUserGeneral(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER Buffer)
Definition: samrpc.c:7323
pServerMapping
PGENERIC_MAPPING pServerMapping
Definition: samrpc.c:56
SampSetUserInternal1
static NTSTATUS SampSetUserInternal1(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER Buffer)
Definition: samrpc.c:7504
SamrRemoveMultipleMembersFromAlias
NTSTATUS NTAPI SamrRemoveMultipleMembersFromAlias(IN SAMPR_HANDLE AliasHandle, IN PSAMPR_PSID_ARRAY MembersBuffer)
Definition: samrpc.c:9324
SampSetGroupName
static NTSTATUS SampSetGroupName(PSAM_DB_OBJECT GroupObject, PSAMPR_GROUP_INFO_BUFFER Buffer)
Definition: samrpc.c:4312
SamrAddMemberToGroup
NTSTATUS NTAPI SamrAddMemberToGroup(IN SAMPR_HANDLE GroupHandle, IN unsigned long MemberId, IN unsigned long Attributes)
Definition: samrpc.c:4474
SampQueryUserAccountName
static NTSTATUS SampQueryUserAccountName(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:6149
SampQueryDomainServerRole
static NTSTATUS SampQueryDomainServerRole(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:1282
SamrCreateUser2InDomain
NTSTATUS NTAPI SamrCreateUser2InDomain(IN SAMPR_HANDLE DomainHandle, IN PRPC_UNICODE_STRING Name, IN unsigned long AccountType, IN ACCESS_MASK DesiredAccess, OUT SAMPR_HANDLE *UserHandle, OUT unsigned long *GrantedAccess, OUT unsigned long *RelativeId)
Definition: samrpc.c:8829
SamrValidatePassword
NTSTATUS NTAPI SamrValidatePassword(IN handle_t Handle, IN PASSWORD_POLICY_VALIDATION_TYPE ValidationType, IN PSAM_VALIDATE_INPUT_ARG InputArg, OUT PSAM_VALIDATE_OUTPUT_ARG *OutputArg)
Definition: samrpc.c:9819
SamrSetSecurityObject
NTSTATUS NTAPI SamrSetSecurityObject(IN SAMPR_HANDLE ObjectHandle, IN SECURITY_INFORMATION SecurityInformation, IN PSAMPR_SR_SECURITY_DESCRIPTOR SecurityDescriptor)
Definition: samrpc.c:192
SampSetUserPrimaryGroup
static NTSTATUS SampSetUserPrimaryGroup(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER Buffer)
Definition: samrpc.c:7413
SamrSetInformationDomain
NTSTATUS NTAPI SamrSetInformationDomain(IN SAMPR_HANDLE DomainHandle, IN DOMAIN_INFORMATION_CLASS DomainInformationClass, IN PSAMPR_DOMAIN_INFO_BUFFER DomainInformation)
Definition: samrpc.c:1794
SamrConnect
NTSTATUS NTAPI SamrConnect(IN PSAMPR_SERVER_NAME ServerName, OUT SAMPR_HANDLE *ServerHandle, IN ACCESS_MASK DesiredAccess)
Definition: samrpc.c:135
SamrConnect2
NTSTATUS NTAPI SamrConnect2(IN PSAMPR_SERVER_NAME ServerName, OUT SAMPR_HANDLE *ServerHandle, IN ACCESS_MASK DesiredAccess)
Definition: samrpc.c:9446
SampQueryDomainGeneral
static NTSTATUS SampQueryDomainGeneral(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:1001
SamrDeleteAlias
NTSTATUS NTAPI SamrDeleteAlias(IN OUT SAMPR_HANDLE *AliasHandle)
Definition: samrpc.c:5226
SamrQueryInformationUser
NTSTATUS NTAPI SamrQueryInformationUser(IN SAMPR_HANDLE UserHandle, IN USER_INFORMATION_CLASS UserInformationClass, OUT PSAMPR_USER_INFO_BUFFER *Buffer)
Definition: samrpc.c:7238
SampQueryDomainGeneral2
static NTSTATUS SampQueryDomainGeneral2(PSAM_DB_OBJECT DomainObject, PSAMPR_DOMAIN_INFO_BUFFER *Buffer)
Definition: samrpc.c:1408
SampSetAliasName
static NTSTATUS SampSetAliasName(PSAM_DB_OBJECT AliasObject, PSAMPR_ALIAS_INFO_BUFFER Buffer)
Definition: samrpc.c:5099
ServerMapping
static GENERIC_MAPPING ServerMapping
Definition: samrpc.c:16
SampSetUserControl
static NTSTATUS SampSetUserControl(PSAM_DB_OBJECT UserObject, PSAMPR_USER_INFO_BUFFER Buffer)
Definition: samrpc.c:7443
SampResource
RTL_RESOURCE SampResource
Definition: samsrv.c:28
EmptyLmHash
ENCRYPTED_LM_OWF_PASSWORD EmptyLmHash
Definition: samsrv.c:27
EmptyNtHash
ENCRYPTED_NT_OWF_PASSWORD EmptyNtHash
Definition: samsrv.c:26
ConvertSidToStringSid
#define ConvertSidToStringSid
Definition: sddl.h:160
midl_user_free
#define midl_user_free
Definition: rpc.h:41
__RPC_FAR
#define __RPC_FAR
Definition: rpc.h:52
RPC_STATUS
long RPC_STATUS
Definition: rpc.h:48
__RPC_USER
#define __RPC_USER
Definition: rpc.h:61
midl_user_allocate
#define midl_user_allocate
Definition: rpc.h:40
memset
#define memset(x, y, z)
Definition: compat.h:39
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
STATUS_BUFFER_TOO_SMALL
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
STATUS_BUFFER_OVERFLOW
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
RPC_SHORT_BLOB::Buffer
unsigned short * Buffer
Definition: msv1_0.h:40
RPC_SHORT_BLOB::MaximumLength
unsigned short MaximumLength
Definition: msv1_0.h:39
RPC_SHORT_BLOB::Length
unsigned short Length
Definition: msv1_0.h:38
SAMPR_DOMAIN_REPLICATION_INFORMATION::ReplicaSourceNodeName
RPC_UNICODE_STRING ReplicaSourceNodeName
Definition: sam.idl:237
_DOMAIN_LOGOFF_INFORMATION::ForceLogoff
LARGE_INTEGER ForceLogoff
Definition: ntsam.h:399
_DOMAIN_MODIFIED_INFORMATION2::DomainModifiedCount
LARGE_INTEGER DomainModifiedCount
Definition: ntsam.h:457
_DOMAIN_MODIFIED_INFORMATION2::ModifiedCountAtLastPromotion
LARGE_INTEGER ModifiedCountAtLastPromotion
Definition: ntsam.h:459
_DOMAIN_MODIFIED_INFORMATION2::CreationTime
LARGE_INTEGER CreationTime
Definition: ntsam.h:458
_DOMAIN_MODIFIED_INFORMATION::DomainModifiedCount
LARGE_INTEGER DomainModifiedCount
Definition: ntsam.h:424
_DOMAIN_MODIFIED_INFORMATION::CreationTime
LARGE_INTEGER CreationTime
Definition: ntsam.h:425
_DOMAIN_PASSWORD_INFORMATION::PasswordHistoryLength
USHORT PasswordHistoryLength
Definition: ntsam.h:373
_DOMAIN_PASSWORD_INFORMATION::MinPasswordAge
LARGE_INTEGER MinPasswordAge
Definition: ntsam.h:376
_DOMAIN_PASSWORD_INFORMATION::PasswordProperties
ULONG PasswordProperties
Definition: ntsam.h:374
_DOMAIN_PASSWORD_INFORMATION::MaxPasswordAge
LARGE_INTEGER MaxPasswordAge
Definition: ntsam.h:375
_DOMAIN_PASSWORD_INFORMATION::MinPasswordLength
USHORT MinPasswordLength
Definition: ntsam.h:372
_DOMAIN_SERVER_ROLE_INFORMATION::DomainServerRole
DOMAIN_SERVER_ROLE DomainServerRole
Definition: ntsam.h:419
_DOMAIN_STATE_INFORMATION::DomainServerState
DOMAIN_SERVER_ENABLE_STATE DomainServerState
Definition: ntsam.h:430
_ENCRYPTED_LM_OWF_PASSWORD
Definition: msv1_0.h:50
_GENERIC_MAPPING
Definition: nt_native.h:564
_GROUP_MEMBERSHIP
Definition: ntsam.h:495
_GROUP_MEMBERSHIP::RelativeId
ULONG RelativeId
Definition: ntsam.h:496
_GROUP_MEMBERSHIP::Attributes
ULONG Attributes
Definition: ntsam.h:497
_LM_OWF_PASSWORD
Definition: subauth.h:99
_OLD_LARGE_INTEGER::LowPart
unsigned long LowPart
Definition: msv1_0.h:32
_OLD_LARGE_INTEGER::HighPart
long HighPart
Definition: msv1_0.h:33
_RPC_SID
Definition: msv1_0.h:13
_RPC_STRING
Definition: eventlogrpc.idl:16
_RPC_UNICODE_STRING
Definition: msv1_0.h:21
_RPC_UNICODE_STRING::Length
unsigned short Length
Definition: msv1_0.h:22
_RPC_UNICODE_STRING::MaximumLength
unsigned short MaximumLength
Definition: msv1_0.h:23
_RPC_UNICODE_STRING::Buffer
wchar_t * Buffer
Definition: msv1_0.h:24
_SAMPR_ALIAS_ADM_COMMENT_INFORMATION::AdminComment
RPC_UNICODE_STRING AdminComment
Definition: sam.idl:429
_SAMPR_ALIAS_GENERAL_INFORMATION::Name
RPC_UNICODE_STRING Name
Definition: sam.idl:417
_SAMPR_ALIAS_GENERAL_INFORMATION::MemberCount
ULONG MemberCount
Definition: sam.idl:418
_SAMPR_ALIAS_GENERAL_INFORMATION::AdminComment
RPC_UNICODE_STRING AdminComment
Definition: sam.idl:419
_SAMPR_ALIAS_NAME_INFORMATION::Name
RPC_UNICODE_STRING Name
Definition: sam.idl:424
_SAMPR_DOMAIN_GENERAL_INFORMATION2::LockoutObservationWindow
LARGE_INTEGER LockoutObservationWindow
Definition: sam.idl:220
_SAMPR_DOMAIN_GENERAL_INFORMATION2::LockoutDuration
LARGE_INTEGER LockoutDuration
Definition: sam.idl:219
_SAMPR_DOMAIN_GENERAL_INFORMATION2::I1
SAMPR_DOMAIN_GENERAL_INFORMATION I1
Definition: sam.idl:218
_SAMPR_DOMAIN_GENERAL_INFORMATION2::LockoutThreshold
unsigned short LockoutThreshold
Definition: sam.idl:221
_SAMPR_DOMAIN_GENERAL_INFORMATION::OemInformation
RPC_UNICODE_STRING OemInformation
Definition: sam.idl:204
_SAMPR_DOMAIN_GENERAL_INFORMATION::ForceLogoff
OLD_LARGE_INTEGER ForceLogoff
Definition: sam.idl:203
_SAMPR_DOMAIN_GENERAL_INFORMATION::UserCount
unsigned long UserCount
Definition: sam.idl:211
_SAMPR_DOMAIN_GENERAL_INFORMATION::DomainServerRole
unsigned long DomainServerRole
Definition: sam.idl:209
_SAMPR_DOMAIN_GENERAL_INFORMATION::AliasCount
unsigned long AliasCount
Definition: sam.idl:213
_SAMPR_DOMAIN_GENERAL_INFORMATION::UasCompatibilityRequired
unsigned char UasCompatibilityRequired
Definition: sam.idl:210
_SAMPR_DOMAIN_GENERAL_INFORMATION::ReplicaSourceNodeName
RPC_UNICODE_STRING ReplicaSourceNodeName
Definition: sam.idl:206
_SAMPR_DOMAIN_GENERAL_INFORMATION::DomainModifiedCount
OLD_LARGE_INTEGER DomainModifiedCount
Definition: sam.idl:207
_SAMPR_DOMAIN_GENERAL_INFORMATION::GroupCount
unsigned long GroupCount
Definition: sam.idl:212
_SAMPR_DOMAIN_GENERAL_INFORMATION::DomainName
RPC_UNICODE_STRING DomainName
Definition: sam.idl:205
_SAMPR_DOMAIN_GENERAL_INFORMATION::DomainServerState
unsigned long DomainServerState
Definition: sam.idl:208
_SAMPR_DOMAIN_LOCKOUT_INFORMATION::LockoutDuration
LARGE_INTEGER LockoutDuration
Definition: sam.idl:242
_SAMPR_DOMAIN_LOCKOUT_INFORMATION::LockoutThreshold
unsigned short LockoutThreshold
Definition: sam.idl:244
_SAMPR_DOMAIN_LOCKOUT_INFORMATION::LockoutObservationWindow
LARGE_INTEGER LockoutObservationWindow
Definition: sam.idl:243
_SAMPR_DOMAIN_NAME_INFORMATION::DomainName
RPC_UNICODE_STRING DomainName
Definition: sam.idl:232
_SAMPR_DOMAIN_OEM_INFORMATION::OemInformation
RPC_UNICODE_STRING OemInformation
Definition: sam.idl:227
_SAMPR_ENCRYPTED_USER_PASSWORD
Definition: sam.idl:449
_SAMPR_ENUMERATION_BUFFER
Definition: sam.idl:94
_SAMPR_ENUMERATION_BUFFER::Buffer
PSAMPR_RID_ENUMERATION Buffer
Definition: sam.idl:96
_SAMPR_ENUMERATION_BUFFER::EntriesRead
unsigned long EntriesRead
Definition: sam.idl:95
_SAMPR_GET_GROUPS_BUFFER
Definition: sam.idl:114
_SAMPR_GET_GROUPS_BUFFER::MembershipCount
unsigned long MembershipCount
Definition: sam.idl:115
_SAMPR_GET_GROUPS_BUFFER::Groups
PGROUP_MEMBERSHIP Groups
Definition: sam.idl:116
_SAMPR_GET_MEMBERS_BUFFER
Definition: sam.idl:120
_SAMPR_GET_MEMBERS_BUFFER::Members
unsigned long * Members
Definition: sam.idl:122
_SAMPR_GET_MEMBERS_BUFFER::MemberCount
unsigned long MemberCount
Definition: sam.idl:121
_SAMPR_GET_MEMBERS_BUFFER::Attributes
unsigned long * Attributes
Definition: sam.idl:123
_SAMPR_GROUP_ADM_COMMENT_INFORMATION::AdminComment
RPC_UNICODE_STRING AdminComment
Definition: sam.idl:392
_SAMPR_GROUP_ATTRIBUTE_INFORMATION::Attributes
unsigned long Attributes
Definition: sam.idl:374
_SAMPR_GROUP_GENERAL_INFORMATION::Name
RPC_UNICODE_STRING Name
Definition: sam.idl:379
_SAMPR_GROUP_GENERAL_INFORMATION::Attributes
unsigned long Attributes
Definition: sam.idl:380
_SAMPR_GROUP_GENERAL_INFORMATION::AdminComment
RPC_UNICODE_STRING AdminComment
Definition: sam.idl:382
_SAMPR_GROUP_GENERAL_INFORMATION::MemberCount
unsigned long MemberCount
Definition: sam.idl:381
_SAMPR_GROUP_NAME_INFORMATION::Name
RPC_UNICODE_STRING Name
Definition: sam.idl:387
_SAMPR_LOGON_HOURS::LogonHours
unsigned char * LogonHours
Definition: msv1_0.h:63
_SAMPR_PSID_ARRAY_OUT
Definition: sam.idl:54
_SAMPR_PSID_ARRAY
Definition: authpackage.c:121
_SAMPR_RETURNED_USTRING_ARRAY
Definition: lookup.c:20
_SAMPR_RID_ENUMERATION
Definition: sam.idl:88
_SAMPR_RID_ENUMERATION::RelativeId
unsigned long RelativeId
Definition: sam.idl:89
_SAMPR_RID_ENUMERATION::Name
RPC_UNICODE_STRING Name
Definition: sam.idl:90
_SAMPR_SID_INFORMATION
Definition: authpackage.c:116
_SAMPR_SR_SECURITY_DESCRIPTOR
Definition: msv1_0.h:44
_SAMPR_SR_SECURITY_DESCRIPTOR::Length
unsigned long Length
Definition: msv1_0.h:45
_SAMPR_SR_SECURITY_DESCRIPTOR::SecurityDescriptor
unsigned char * SecurityDescriptor
Definition: msv1_0.h:46
_SAMPR_ULONG_ARRAY
Definition: lsasrv.h:86
_SAMPR_USER_ACCOUNT_INFORMATION::FullName
RPC_UNICODE_STRING FullName
Definition: sam.idl:565
_SAMPR_USER_ACCOUNT_INFORMATION::LogonHours
SAMPR_LOGON_HOURS LogonHours
Definition: sam.idl:576
_SAMPR_USER_ACCOUNT_INFORMATION::LastLogoff
OLD_LARGE_INTEGER LastLogoff
Definition: sam.idl:575
_SAMPR_USER_ACCOUNT_INFORMATION::HomeDirectoryDrive
RPC_UNICODE_STRING HomeDirectoryDrive
Definition: sam.idl:569
_SAMPR_USER_ACCOUNT_INFORMATION::ScriptPath
RPC_UNICODE_STRING ScriptPath
Definition: sam.idl:570
_SAMPR_USER_ACCOUNT_INFORMATION::UserAccountControl
unsigned long UserAccountControl
Definition: sam.idl:581
_SAMPR_USER_ACCOUNT_INFORMATION::PasswordLastSet
OLD_LARGE_INTEGER PasswordLastSet
Definition: sam.idl:579
_SAMPR_USER_ACCOUNT_INFORMATION::BadPasswordCount
unsigned short BadPasswordCount
Definition: sam.idl:577
_SAMPR_USER_ACCOUNT_INFORMATION::ProfilePath
RPC_UNICODE_STRING ProfilePath
Definition: sam.idl:571
_SAMPR_USER_ACCOUNT_INFORMATION::UserId
unsigned long UserId
Definition: sam.idl:566
_SAMPR_USER_ACCOUNT_INFORMATION::HomeDirectory
RPC_UNICODE_STRING HomeDirectory
Definition: sam.idl:568
_SAMPR_USER_ACCOUNT_INFORMATION::AdminComment
RPC_UNICODE_STRING AdminComment
Definition: sam.idl:572
_SAMPR_USER_ACCOUNT_INFORMATION::AccountExpires
OLD_LARGE_INTEGER AccountExpires
Definition: sam.idl:580
_SAMPR_USER_ACCOUNT_INFORMATION::UserName
RPC_UNICODE_STRING UserName
Definition: sam.idl:564
_SAMPR_USER_ACCOUNT_INFORMATION::LogonCount
unsigned short LogonCount
Definition: sam.idl:578
_SAMPR_USER_ACCOUNT_INFORMATION::PrimaryGroupId
unsigned long PrimaryGroupId
Definition: sam.idl:567
_SAMPR_USER_ACCOUNT_INFORMATION::WorkStations
RPC_UNICODE_STRING WorkStations
Definition: sam.idl:573
_SAMPR_USER_ACCOUNT_INFORMATION::LastLogon
OLD_LARGE_INTEGER LastLogon
Definition: sam.idl:574
_SAMPR_USER_ADMIN_COMMENT_INFORMATION::AdminComment
RPC_UNICODE_STRING AdminComment
Definition: sam.idl:618
_SAMPR_USER_ALL_INFORMATION::BadPasswordCount
unsigned short BadPasswordCount
Definition: msv1_0.h:105
_SAMPR_USER_ALL_INFORMATION::LogonCount
unsigned short LogonCount
Definition: msv1_0.h:106
_SAMPR_USER_ALL_INFORMATION::PasswordMustChange
OLD_LARGE_INTEGER PasswordMustChange
Definition: msv1_0.h:85
_SAMPR_USER_ALL_INFORMATION::PrimaryGroupId
unsigned long PrimaryGroupId
Definition: msv1_0.h:101
_SAMPR_USER_ALL_INFORMATION::PasswordLastSet
OLD_LARGE_INTEGER PasswordLastSet
Definition: msv1_0.h:82
_SAMPR_USER_ALL_INFORMATION::CodePage
unsigned short CodePage
Definition: msv1_0.h:108
_SAMPR_USER_ALL_INFORMATION::NtOwfPassword
RPC_SHORT_BLOB NtOwfPassword
Definition: msv1_0.h:97
_SAMPR_USER_ALL_INFORMATION::UserName
RPC_UNICODE_STRING UserName
Definition: msv1_0.h:86
_SAMPR_USER_ALL_INFORMATION::PasswordCanChange
OLD_LARGE_INTEGER PasswordCanChange
Definition: msv1_0.h:84
_SAMPR_USER_ALL_INFORMATION::WhichFields
unsigned long WhichFields
Definition: msv1_0.h:103
_SAMPR_USER_ALL_INFORMATION::LastLogon
OLD_LARGE_INTEGER LastLogon
Definition: msv1_0.h:80
_SAMPR_USER_ALL_INFORMATION::Parameters
RPC_UNICODE_STRING Parameters
Definition: msv1_0.h:95
_SAMPR_USER_ALL_INFORMATION::ProfilePath
RPC_UNICODE_STRING ProfilePath
Definition: msv1_0.h:91
_SAMPR_USER_ALL_INFORMATION::PrivateData
RPC_UNICODE_STRING PrivateData
Definition: msv1_0.h:98
_SAMPR_USER_ALL_INFORMATION::FullName
RPC_UNICODE_STRING FullName
Definition: msv1_0.h:87
_SAMPR_USER_ALL_INFORMATION::HomeDirectoryDrive
RPC_UNICODE_STRING HomeDirectoryDrive
Definition: msv1_0.h:89
_SAMPR_USER_ALL_INFORMATION::LogonHours
SAMPR_LOGON_HOURS LogonHours
Definition: msv1_0.h:104
_SAMPR_USER_ALL_INFORMATION::CountryCode
unsigned short CountryCode
Definition: msv1_0.h:107
_SAMPR_USER_ALL_INFORMATION::UserComment
RPC_UNICODE_STRING UserComment
Definition: msv1_0.h:94
_SAMPR_USER_ALL_INFORMATION::LastLogoff
OLD_LARGE_INTEGER LastLogoff
Definition: msv1_0.h:81
_SAMPR_USER_ALL_INFORMATION::ScriptPath
RPC_UNICODE_STRING ScriptPath
Definition: msv1_0.h:90
_SAMPR_USER_ALL_INFORMATION::AdminComment
RPC_UNICODE_STRING AdminComment
Definition: msv1_0.h:92
_SAMPR_USER_ALL_INFORMATION::HomeDirectory
RPC_UNICODE_STRING HomeDirectory
Definition: msv1_0.h:88
_SAMPR_USER_ALL_INFORMATION::UserId
unsigned long UserId
Definition: msv1_0.h:100
_SAMPR_USER_ALL_INFORMATION::LmPasswordPresent
unsigned char LmPasswordPresent
Definition: msv1_0.h:109
_SAMPR_USER_ALL_INFORMATION::SecurityDescriptor
SAMPR_SR_SECURITY_DESCRIPTOR SecurityDescriptor
Definition: msv1_0.h:99
_SAMPR_USER_ALL_INFORMATION::AccountExpires
OLD_LARGE_INTEGER AccountExpires
Definition: msv1_0.h:83
_SAMPR_USER_ALL_INFORMATION::UserAccountControl
unsigned long UserAccountControl
Definition: msv1_0.h:102
_SAMPR_USER_ALL_INFORMATION::LmOwfPassword
RPC_SHORT_BLOB LmOwfPassword
Definition: msv1_0.h:96
_SAMPR_USER_ALL_INFORMATION::NtPasswordPresent
unsigned char NtPasswordPresent
Definition: msv1_0.h:110
_SAMPR_USER_ALL_INFORMATION::WorkStations
RPC_UNICODE_STRING WorkStations
Definition: msv1_0.h:93
_SAMPR_USER_A_NAME_INFORMATION::UserName
RPC_UNICODE_STRING UserName
Definition: sam.idl:586
_SAMPR_USER_F_NAME_INFORMATION::FullName
RPC_UNICODE_STRING FullName
Definition: sam.idl:591
_SAMPR_USER_GENERAL_INFORMATION::UserName
RPC_UNICODE_STRING UserName
Definition: sam.idl:520
_SAMPR_USER_GENERAL_INFORMATION::AdminComment
RPC_UNICODE_STRING AdminComment
Definition: sam.idl:523
_SAMPR_USER_GENERAL_INFORMATION::PrimaryGroupId
unsigned long PrimaryGroupId
Definition: sam.idl:522
_SAMPR_USER_GENERAL_INFORMATION::UserComment
RPC_UNICODE_STRING UserComment
Definition: sam.idl:524
_SAMPR_USER_GENERAL_INFORMATION::FullName
RPC_UNICODE_STRING FullName
Definition: sam.idl:521
_SAMPR_USER_HOME_INFORMATION::HomeDirectory
RPC_UNICODE_STRING HomeDirectory
Definition: sam.idl:602
_SAMPR_USER_HOME_INFORMATION::HomeDirectoryDrive
RPC_UNICODE_STRING HomeDirectoryDrive
Definition: sam.idl:603
_SAMPR_USER_INTERNAL1_INFORMATION::LmPasswordPresent
BOOLEAN LmPasswordPresent
Definition: sam.idl:643
_SAMPR_USER_INTERNAL1_INFORMATION::PasswordExpired
BOOLEAN PasswordExpired
Definition: sam.idl:644
_SAMPR_USER_INTERNAL1_INFORMATION::EncryptedNtOwfPassword
ENCRYPTED_NT_OWF_PASSWORD EncryptedNtOwfPassword
Definition: sam.idl:640
_SAMPR_USER_INTERNAL1_INFORMATION::EncryptedLmOwfPassword
ENCRYPTED_LM_OWF_PASSWORD EncryptedLmOwfPassword
Definition: sam.idl:641
_SAMPR_USER_INTERNAL1_INFORMATION::NtPasswordPresent
BOOLEAN NtPasswordPresent
Definition: sam.idl:642
_SAMPR_USER_INTERNAL2_INFORMATION::LogonCount
unsigned short LogonCount
Definition: msv1_0.h:75
_SAMPR_USER_INTERNAL2_INFORMATION::LastLogon
OLD_LARGE_INTEGER LastLogon
Definition: msv1_0.h:72
_SAMPR_USER_INTERNAL2_INFORMATION::Flags
unsigned long Flags
Definition: msv1_0.h:71
_SAMPR_USER_INTERNAL2_INFORMATION::BadPasswordCount
unsigned short BadPasswordCount
Definition: msv1_0.h:74
_SAMPR_USER_INTERNAL2_INFORMATION::LastLogoff
OLD_LARGE_INTEGER LastLogoff
Definition: msv1_0.h:73
_SAMPR_USER_LOGON_HOURS_INFORMATION::LogonHours
SAMPR_LOGON_HOURS LogonHours
Definition: sam.idl:635
_SAMPR_USER_LOGON_INFORMATION::HomeDirectory
RPC_UNICODE_STRING HomeDirectory
Definition: sam.idl:546
_SAMPR_USER_LOGON_INFORMATION::PrimaryGroupId
unsigned long PrimaryGroupId
Definition: sam.idl:545
_SAMPR_USER_LOGON_INFORMATION::ProfilePath
RPC_UNICODE_STRING ProfilePath
Definition: sam.idl:549
_SAMPR_USER_LOGON_INFORMATION::UserAccountControl
unsigned long UserAccountControl
Definition: sam.idl:559
_SAMPR_USER_LOGON_INFORMATION::PasswordLastSet
OLD_LARGE_INTEGER PasswordLastSet
Definition: sam.idl:553
_SAMPR_USER_LOGON_INFORMATION::BadPasswordCount
unsigned short BadPasswordCount
Definition: sam.idl:557
_SAMPR_USER_LOGON_INFORMATION::LastLogon
OLD_LARGE_INTEGER LastLogon
Definition: sam.idl:551
_SAMPR_USER_LOGON_INFORMATION::LogonHours
SAMPR_LOGON_HOURS LogonHours
Definition: sam.idl:556
_SAMPR_USER_LOGON_INFORMATION::UserName
RPC_UNICODE_STRING UserName
Definition: sam.idl:542
_SAMPR_USER_LOGON_INFORMATION::ScriptPath
RPC_UNICODE_STRING ScriptPath
Definition: sam.idl:548
_SAMPR_USER_LOGON_INFORMATION::PasswordMustChange
OLD_LARGE_INTEGER PasswordMustChange
Definition: sam.idl:555
_SAMPR_USER_LOGON_INFORMATION::PasswordCanChange
OLD_LARGE_INTEGER PasswordCanChange
Definition: sam.idl:554
_SAMPR_USER_LOGON_INFORMATION::LogonCount
unsigned short LogonCount
Definition: sam.idl:558
_SAMPR_USER_LOGON_INFORMATION::FullName
RPC_UNICODE_STRING FullName
Definition: sam.idl:543
_SAMPR_USER_LOGON_INFORMATION::LastLogoff
OLD_LARGE_INTEGER LastLogoff
Definition: sam.idl:552
_SAMPR_USER_LOGON_INFORMATION::WorkStations
RPC_UNICODE_STRING WorkStations
Definition: sam.idl:550
_SAMPR_USER_LOGON_INFORMATION::UserId
unsigned long UserId
Definition: sam.idl:544
_SAMPR_USER_LOGON_INFORMATION::HomeDirectoryDrive
RPC_UNICODE_STRING HomeDirectoryDrive
Definition: sam.idl:547
_SAMPR_USER_NAME_INFORMATION::FullName
RPC_UNICODE_STRING FullName
Definition: sam.idl:597
_SAMPR_USER_NAME_INFORMATION::UserName
RPC_UNICODE_STRING UserName
Definition: sam.idl:596
_SAMPR_USER_PARAMETERS_INFORMATION::Parameters
RPC_UNICODE_STRING Parameters
Definition: sam.idl:537
_SAMPR_USER_PREFERENCES_INFORMATION::UserComment
RPC_UNICODE_STRING UserComment
Definition: sam.idl:529
_SAMPR_USER_PREFERENCES_INFORMATION::CodePage
unsigned short CodePage
Definition: sam.idl:532
_SAMPR_USER_PREFERENCES_INFORMATION::CountryCode
unsigned short CountryCode
Definition: sam.idl:531
_SAMPR_USER_PROFILE_INFORMATION::ProfilePath
RPC_UNICODE_STRING ProfilePath
Definition: sam.idl:613
_SAMPR_USER_SCRIPT_INFORMATION::ScriptPath
RPC_UNICODE_STRING ScriptPath
Definition: sam.idl:608
_SAMPR_USER_WORKSTATIONS_INFORMATION::WorkStations
RPC_UNICODE_STRING WorkStations
Definition: sam.idl:623
_SAM_DB_OBJECT
Definition: samsrv.h:46
_SAM_DB_OBJECT::KeyHandle
HANDLE KeyHandle
Definition: samsrv.h:52
_SAM_DB_OBJECT::Trusted
BOOLEAN Trusted
Definition: samsrv.h:55
_SAM_DB_OBJECT::Access
ACCESS_MASK Access
Definition: samsrv.h:50
_SAM_DB_OBJECT::ObjectType
SAM_DB_OBJECT_TYPE ObjectType
Definition: samsrv.h:48
_SAM_DB_OBJECT::RelativeId
ULONG RelativeId
Definition: samsrv.h:54
_SAM_DB_OBJECT::ParentObject
struct _SAM_DB_OBJECT * ParentObject
Definition: samsrv.h:56
_SAM_DOMAIN_FIXED_DATA
Definition: samsrv.h:69
_SAM_DOMAIN_FIXED_DATA::DomainServerState
DOMAIN_SERVER_ENABLE_STATE DomainServerState
Definition: samsrv.h:85
_SAM_DOMAIN_FIXED_DATA::CreationTime
LARGE_INTEGER CreationTime
Definition: samsrv.h:72
_SAM_DOMAIN_FIXED_DATA::NextRid
ULONG NextRid
Definition: samsrv.h:80
_SAM_DOMAIN_FIXED_DATA::PasswordHistoryLength
USHORT PasswordHistoryLength
Definition: samsrv.h:83
_SAM_DOMAIN_FIXED_DATA::LockoutObservationWindow
LARGE_INTEGER LockoutObservationWindow
Definition: samsrv.h:78
_SAM_DOMAIN_FIXED_DATA::DomainServerRole
DOMAIN_SERVER_ROLE DomainServerRole
Definition: samsrv.h:86
_SAM_DOMAIN_FIXED_DATA::MaxPasswordAge
LARGE_INTEGER MaxPasswordAge
Definition: samsrv.h:74
_SAM_DOMAIN_FIXED_DATA::LockoutDuration
LARGE_INTEGER LockoutDuration
Definition: samsrv.h:77
_SAM_DOMAIN_FIXED_DATA::LockoutThreshold
USHORT LockoutThreshold
Definition: samsrv.h:84
_SAM_DOMAIN_FIXED_DATA::UasCompatibilityRequired
BOOLEAN UasCompatibilityRequired
Definition: samsrv.h:87
_SAM_DOMAIN_FIXED_DATA::MinPasswordLength
USHORT MinPasswordLength
Definition: samsrv.h:82
_SAM_DOMAIN_FIXED_DATA::ModifiedCountAtLastPromotion
LARGE_INTEGER ModifiedCountAtLastPromotion
Definition: samsrv.h:79
_SAM_DOMAIN_FIXED_DATA::MinPasswordAge
LARGE_INTEGER MinPasswordAge
Definition: samsrv.h:75
_SAM_DOMAIN_FIXED_DATA::DomainModifiedCount
LARGE_INTEGER DomainModifiedCount
Definition: samsrv.h:73
_SAM_DOMAIN_FIXED_DATA::ForceLogoff
LARGE_INTEGER ForceLogoff
Definition: samsrv.h:76
_SAM_DOMAIN_FIXED_DATA::PasswordProperties
ULONG PasswordProperties
Definition: samsrv.h:81
_SAM_GROUP_FIXED_DATA
Definition: samsrv.h:91
_SAM_GROUP_FIXED_DATA::Version
ULONG Version
Definition: samsrv.h:92
_SAM_GROUP_FIXED_DATA::GroupId
ULONG GroupId
Definition: samsrv.h:94
_SAM_GROUP_FIXED_DATA::Attributes
ULONG Attributes
Definition: samsrv.h:95
_SAM_USER_FIXED_DATA
Definition: samsrv.h:99
_SAM_USER_FIXED_DATA::LastBadPasswordTime
LARGE_INTEGER LastBadPasswordTime
Definition: samsrv.h:106
_SAM_USER_FIXED_DATA::AccountExpires
LARGE_INTEGER AccountExpires
Definition: samsrv.h:105
_SAM_USER_FIXED_DATA::UserAccountControl
ULONG UserAccountControl
Definition: samsrv.h:109
_SAM_USER_FIXED_DATA::LastLogon
LARGE_INTEGER LastLogon
Definition: samsrv.h:102
_SAM_USER_FIXED_DATA::PrimaryGroupId
ULONG PrimaryGroupId
Definition: samsrv.h:108
_SAM_USER_FIXED_DATA::Version
ULONG Version
Definition: samsrv.h:100
_SAM_USER_FIXED_DATA::PasswordLastSet
LARGE_INTEGER PasswordLastSet
Definition: samsrv.h:104
_SAM_USER_FIXED_DATA::BadPasswordCount
USHORT BadPasswordCount
Definition: samsrv.h:112
_SAM_USER_FIXED_DATA::CountryCode
USHORT CountryCode
Definition: samsrv.h:110
_SAM_USER_FIXED_DATA::CodePage
USHORT CodePage
Definition: samsrv.h:111
_SAM_USER_FIXED_DATA::UserId
ULONG UserId
Definition: samsrv.h:107
_SAM_USER_FIXED_DATA::LastLogoff
LARGE_INTEGER LastLogoff
Definition: samsrv.h:103
_SAM_USER_FIXED_DATA::OperatorCount
USHORT OperatorCount
Definition: samsrv.h:115
_SAM_USER_FIXED_DATA::AdminCount
USHORT AdminCount
Definition: samsrv.h:114
_SAM_USER_FIXED_DATA::LogonCount
USHORT LogonCount
Definition: samsrv.h:113
_SAM_USER_FIXED_DATA::Reserved
ULONG Reserved
Definition: samsrv.h:101
_SECURITY_DESCRIPTOR_RELATIVE
Definition: setypes.h:848
_SECURITY_DESCRIPTOR_RELATIVE::Control
SECURITY_DESCRIPTOR_CONTROL Control
Definition: setypes.h:851
_SECURITY_DESCRIPTOR_RELATIVE::Group
$ULONG Group
Definition: setypes.h:853
_SECURITY_DESCRIPTOR_RELATIVE::Owner
$ULONG Owner
Definition: setypes.h:852
_SECURITY_DESCRIPTOR
Definition: ms-dtyp.idl:301
_SID_IDENTIFIER_AUTHORITY
Definition: ms-dtyp.idl:194
_SID
Definition: ms-dtyp.idl:198
_UNICODE_STRING
Definition: env_spec_w32.h:368
_UNICODE_STRING::Length
USHORT Length
Definition: env_spec_w32.h:369
_UNICODE_STRING::MaximumLength
USHORT MaximumLength
Definition: env_spec_w32.h:370
_UNICODE_STRING::Buffer
PWSTR Buffer
Definition: env_spec_w32.h:371
_USER_CONTROL_INFORMATION::UserAccountControl
ULONG UserAccountControl
Definition: ntsam.h:670
_USER_DOMAIN_PASSWORD_INFORMATION
Definition: sam.idl:138
_USER_EXPIRES_INFORMATION::AccountExpires
LARGE_INTEGER AccountExpires
Definition: ntsam.h:675
_USER_PRIMARY_GROUP_INFORMATION::PrimaryGroupId
ULONG PrimaryGroupId
Definition: ntsam.h:633
SystemFunction013
NTSTATUS WINAPI SystemFunction013(const BYTE *in, const BYTE *key, LPBYTE out)
Definition: sysfunc.c:383
BindingHandle
_In_ ULONG _Out_ HANDLE * BindingHandle
Definition: tdikrnl.h:1147
MAXULONG
#define MAXULONG
Definition: typedefs.h:251
PULONG
uint32_t * PULONG
Definition: typedefs.h:59
LPCWSTR
const uint16_t * LPCWSTR
Definition: typedefs.h:57
UCHAR
unsigned char UCHAR
Definition: typedefs.h:53
LPBYTE
unsigned char * LPBYTE
Definition: typedefs.h:53
LPWSTR
uint16_t * LPWSTR
Definition: typedefs.h:56
NTAPI
#define NTAPI
Definition: typedefs.h:36
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
PUSHORT
uint16_t * PUSHORT
Definition: typedefs.h:56
IN
#define IN
Definition: typedefs.h:39
ULONG
uint32_t ULONG
Definition: typedefs.h:59
OUT
#define OUT
Definition: typedefs.h:40
STATUS_ACCESS_DENIED
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
STATUS_MORE_ENTRIES
#define STATUS_MORE_ENTRIES
Definition: udferr_usr.h:124
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
STATUS_OBJECT_NAME_NOT_FOUND
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149
MAXLONG
#define MAXLONG
Definition: umtypes.h:116
_LARGE_INTEGER
Definition: typedefs.h:103
_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:114
_LARGE_INTEGER::LowPart
ULONG LowPart
Definition: typedefs.h:106
_LARGE_INTEGER::HighPart
LONG HighPart
Definition: typedefs.h:107
_SAMPR_ALIAS_INFO_BUFFER
Definition: sam.idl:442
_SAMPR_ALIAS_INFO_BUFFER::Name
SAMPR_ALIAS_NAME_INFORMATION Name
Definition: sam.idl:444
_SAMPR_ALIAS_INFO_BUFFER::General
SAMPR_ALIAS_GENERAL_INFORMATION General
Definition: sam.idl:443
_SAMPR_ALIAS_INFO_BUFFER::AdminComment
SAMPR_ALIAS_ADM_COMMENT_INFORMATION AdminComment
Definition: sam.idl:445
_SAMPR_DISPLAY_INFO_BUFFER
Definition: sam.idl:364
_SAMPR_DOMAIN_INFO_BUFFER
Definition: sam.idl:266
_SAMPR_DOMAIN_INFO_BUFFER::Oem
SAMPR_DOMAIN_OEM_INFORMATION Oem
Definition: sam.idl:270
_SAMPR_DOMAIN_INFO_BUFFER::Modified
DOMAIN_MODIFIED_INFORMATION Modified
Definition: sam.idl:274
_SAMPR_DOMAIN_INFO_BUFFER::Logoff
DOMAIN_LOGOFF_INFORMATION Logoff
Definition: sam.idl:269
_SAMPR_DOMAIN_INFO_BUFFER::Role
DOMAIN_SERVER_ROLE_INFORMATION Role
Definition: sam.idl:272
_SAMPR_DOMAIN_INFO_BUFFER::Lockout
SAMPR_DOMAIN_LOCKOUT_INFORMATION Lockout
Definition: sam.idl:277
_SAMPR_DOMAIN_INFO_BUFFER::Password
DOMAIN_PASSWORD_INFORMATION Password
Definition: sam.idl:267
_SAMPR_DOMAIN_INFO_BUFFER::General
SAMPR_DOMAIN_GENERAL_INFORMATION General
Definition: sam.idl:268
_SAMPR_DOMAIN_INFO_BUFFER::General2
SAMPR_DOMAIN_GENERAL_INFORMATION2 General2
Definition: sam.idl:276
_SAMPR_DOMAIN_INFO_BUFFER::Modified2
DOMAIN_MODIFIED_INFORMATION2 Modified2
Definition: sam.idl:278
_SAMPR_DOMAIN_INFO_BUFFER::State
DOMAIN_STATE_INFORMATION State
Definition: sam.idl:275
_SAMPR_DOMAIN_INFO_BUFFER::Replication
SAMPR_DOMAIN_REPLICATION_INFORMATION Replication
Definition: sam.idl:273
_SAMPR_DOMAIN_INFO_BUFFER::Name
SAMPR_DOMAIN_NAME_INFORMATION Name
Definition: sam.idl:271
_SAMPR_GROUP_INFO_BUFFER
Definition: sam.idl:407
_SAMPR_GROUP_INFO_BUFFER::AdminComment
SAMPR_GROUP_ADM_COMMENT_INFORMATION AdminComment
Definition: sam.idl:411
_SAMPR_GROUP_INFO_BUFFER::Attribute
SAMPR_GROUP_ATTRIBUTE_INFORMATION Attribute
Definition: sam.idl:410
_SAMPR_GROUP_INFO_BUFFER::General
SAMPR_GROUP_GENERAL_INFORMATION General
Definition: sam.idl:408
_SAMPR_GROUP_INFO_BUFFER::Name
SAMPR_GROUP_NAME_INFORMATION Name
Definition: sam.idl:409
_SAMPR_USER_INFO_BUFFER
Definition: msv1_0.h:116
_SAMPR_USER_INFO_BUFFER::LogonHours
SAMPR_USER_LOGON_HOURS_INFORMATION LogonHours
Definition: sam.idl:724
_SAMPR_USER_INFO_BUFFER::Name
SAMPR_USER_NAME_INFORMATION Name
Definition: sam.idl:726
_SAMPR_USER_INFO_BUFFER::Internal1
SAMPR_USER_INTERNAL1_INFORMATION Internal1
Definition: sam.idl:738
_SAMPR_USER_INFO_BUFFER::Account
SAMPR_USER_ACCOUNT_INFORMATION Account
Definition: sam.idl:725
_SAMPR_USER_INFO_BUFFER::WorkStations
SAMPR_USER_WORKSTATIONS_INFORMATION WorkStations
Definition: sam.idl:734
_SAMPR_USER_INFO_BUFFER::Control
USER_CONTROL_INFORMATION Control
Definition: sam.idl:736
_SAMPR_USER_INFO_BUFFER::Home
SAMPR_USER_HOME_INFORMATION Home
Definition: sam.idl:730
_SAMPR_USER_INFO_BUFFER::General
SAMPR_USER_GENERAL_INFORMATION General
Definition: sam.idl:721
_SAMPR_USER_INFO_BUFFER::Profile
SAMPR_USER_PROFILE_INFORMATION Profile
Definition: sam.idl:732
_SAMPR_USER_INFO_BUFFER::PrimaryGroup
USER_PRIMARY_GROUP_INFORMATION PrimaryGroup
Definition: sam.idl:729
_SAMPR_USER_INFO_BUFFER::AdminComment
SAMPR_USER_ADMIN_COMMENT_INFORMATION AdminComment
Definition: sam.idl:733
_SAMPR_USER_INFO_BUFFER::Logon
SAMPR_USER_LOGON_INFORMATION Logon
Definition: sam.idl:723
_SAMPR_USER_INFO_BUFFER::All
SAMPR_USER_ALL_INFORMATION All
Definition: msv1_0.h:141
_SAMPR_USER_INFO_BUFFER::Expires
USER_EXPIRES_INFORMATION Expires
Definition: sam.idl:737
_SAMPR_USER_INFO_BUFFER::Script
SAMPR_USER_SCRIPT_INFORMATION Script
Definition: sam.idl:731
_SAMPR_USER_INFO_BUFFER::Parameters
SAMPR_USER_PARAMETERS_INFORMATION Parameters
Definition: sam.idl:740
_SAMPR_USER_INFO_BUFFER::Preferences
SAMPR_USER_PREFERENCES_INFORMATION Preferences
Definition: sam.idl:722
_SAMPR_USER_INFO_BUFFER::Internal2
SAMPR_USER_INTERNAL2_INFORMATION Internal2
Definition: msv1_0.h:137
_SAMPR_USER_INFO_BUFFER::AccountName
SAMPR_USER_A_NAME_INFORMATION AccountName
Definition: sam.idl:727
_SAMPR_USER_INFO_BUFFER::FullName
SAMPR_USER_F_NAME_INFORMATION FullName
Definition: sam.idl:728
_SAM_VALIDATE_INPUT_ARG
Definition: sam.idl:819
_SAM_VALIDATE_OUTPUT_ARG
Definition: sam.idl:826
Count
USHORT Count
Definition: userreq.cpp:200
Index
_In_ WDFCOLLECTION _In_ ULONG Index
Definition: wdfcollection.h:182
DesiredAccess
_Must_inspect_result_ _In_ WDFDEVICE _In_ ULONG _In_ ACCESS_MASK DesiredAccess
Definition: wdfdevice.h:2664
MAX_COMPUTERNAME_LENGTH
#define MAX_COMPUTERNAME_LENGTH
Definition: winbase.h:268
RtlLengthSecurityDescriptor
NTSYSAPI ULONG WINAPI RtlLengthSecurityDescriptor(PSECURITY_DESCRIPTOR)
RequiredLength
_In_ ULONG _Out_opt_ PULONG RequiredLength
Definition: wmifuncs.h:30
SecurityDescriptor
_In_ USHORT _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _Reserved_ ULONG _In_opt_ PVOID _In_opt_ const WSK_CLIENT_CONNECTION_DISPATCH _In_opt_ PEPROCESS _In_opt_ PETHREAD _In_opt_ PSECURITY_DESCRIPTOR SecurityDescriptor
Definition: wsk.h:191
Prefix
_In_ __drv_aliasesMem PSTRING Prefix
Definition: rtlfuncs.h:1647
GrantedAccess
_In_ PSECURITY_SUBJECT_CONTEXT _In_ BOOLEAN _In_ ACCESS_MASK _In_ ACCESS_MASK _Outptr_opt_ PPRIVILEGE_SET _In_ PGENERIC_MAPPING _In_ KPROCESSOR_MODE _Out_ PACCESS_MASK GrantedAccess
Definition: sefuncs.h:20
SECURITY_BUILTIN_DOMAIN_RID
#define SECURITY_BUILTIN_DOMAIN_RID
Definition: setypes.h:581
DACL_SECURITY_INFORMATION
#define DACL_SECURITY_INFORMATION
Definition: setypes.h:125
OWNER_SECURITY_INFORMATION
#define OWNER_SECURITY_INFORMATION
Definition: setypes.h:123
SECURITY_NT_AUTHORITY
#define SECURITY_NT_AUTHORITY
Definition: setypes.h:554
GROUP_SECURITY_INFORMATION
#define GROUP_SECURITY_INFORMATION
Definition: setypes.h:124
SID_MAX_SUB_AUTHORITIES
#define SID_MAX_SUB_AUTHORITIES
Definition: setypes.h:482
SACL_SECURITY_INFORMATION
#define SACL_SECURITY_INFORMATION
Definition: setypes.h:126
DOMAIN_USER_RID_KRBTGT
#define DOMAIN_USER_RID_KRBTGT
Definition: setypes.h:633
SID_REVISION
#define SID_REVISION
Definition: setypes.h:481
SECURITY_NT_NON_UNIQUE
#define SECURITY_NT_NON_UNIQUE
Definition: setypes.h:577
DOMAIN_GROUP_RID_USERS
#define DOMAIN_GROUP_RID_USERS
Definition: setypes.h:640
BYTE
unsigned char BYTE
Definition: xxhash.c:193