ReactOS 0.4.16-dev-1531-gd958a24
lookup.c
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: Local Security Authority (LSA) Server
4 * FILE: reactos/dll/win32/lsasrv/lookup.c
5 * PURPOSE: Sid / Name lookup functions
6 *
7 * PROGRAMMERS: Eric Kohl
8 */
9
10#include "lsasrv.h"
11
12#include "resources.h"
13
14/* GLOBALS *****************************************************************/
15
16typedef wchar_t *PSAMPR_SERVER_NAME;
17typedef void *SAMPR_HANDLE;
18
19typedef struct _SAMPR_RETURNED_USTRING_ARRAY
20{
21 unsigned long Count;
22 PRPC_UNICODE_STRING Element;
23} SAMPR_RETURNED_USTRING_ARRAY, *PSAMPR_RETURNED_USTRING_ARRAY;
24
25VOID
26NTAPI
27SamIFree_SAMPR_RETURNED_USTRING_ARRAY(PSAMPR_RETURNED_USTRING_ARRAY Ptr);
28
29VOID
30NTAPI
31SamIFree_SAMPR_ULONG_ARRAY(PSAMPR_ULONG_ARRAY Ptr);
32
33NTSTATUS
34NTAPI
35SamrConnect(IN PSAMPR_SERVER_NAME ServerName,
36 OUT SAMPR_HANDLE *ServerHandle,
37 IN ACCESS_MASK DesiredAccess);
38
39NTSTATUS
40NTAPI
41SamrCloseHandle(IN OUT SAMPR_HANDLE *SamHandle);
42
43NTSTATUS
44NTAPI
45SamrOpenDomain(IN SAMPR_HANDLE ServerHandle,
46 IN ACCESS_MASK DesiredAccess,
47 IN PRPC_SID DomainId,
48 OUT SAMPR_HANDLE *DomainHandle);
49
50NTSTATUS
51NTAPI
52SamrLookupIdsInDomain(IN SAMPR_HANDLE DomainHandle,
53 IN ULONG Count,
54 IN ULONG *RelativeIds,
55 OUT PSAMPR_RETURNED_USTRING_ARRAY Names,
56 OUT PSAMPR_ULONG_ARRAY Use);
57
58NTSTATUS
59NTAPI
60SamrLookupNamesInDomain(IN SAMPR_HANDLE DomainHandle,
61 IN ULONG Count,
62 IN RPC_UNICODE_STRING Names[],
63 OUT PSAMPR_ULONG_ARRAY RelativeIds,
64 OUT PSAMPR_ULONG_ARRAY Use);
65
66
67typedef struct _WELL_KNOWN_SID
68{
69 LIST_ENTRY ListEntry;
70 PSID Sid;
71 UNICODE_STRING AccountName;
72 UNICODE_STRING DomainName;
73 SID_NAME_USE Use;
74} WELL_KNOWN_SID, *PWELL_KNOWN_SID;
75
76
77LIST_ENTRY WellKnownSidListHead;
78PSID LsapWorldSid = NULL;
79PSID LsapNetworkSid = NULL;
80PSID LsapBatchSid = NULL;
81PSID LsapInteractiveSid = NULL;
82PSID LsapServiceSid = NULL;
83PSID LsapLocalSystemSid = NULL;
84PSID LsapAdministratorsSid = NULL;
85
86
87/* FUNCTIONS ***************************************************************/
88
89BOOLEAN
90LsapCreateSid(PSID_IDENTIFIER_AUTHORITY IdentifierAuthority,
91 UCHAR SubAuthorityCount,
92 PULONG SubAuthorities,
93 PWSTR AccountName,
94 PWSTR DomainName,
95 SID_NAME_USE Use,
96 PSID *SidPtr)
97{
98 PWELL_KNOWN_SID SidEntry;
99 SIZE_T AccountNameLength, DomainNameLength;
100 PULONG p;
101 ULONG i;
102
103 AccountNameLength = wcslen(AccountName);
104 DomainNameLength = wcslen(DomainName);
105 if ((AccountNameLength > UNICODE_STRING_MAX_CHARS) ||
106 (DomainNameLength > UNICODE_STRING_MAX_CHARS))
107 {
108 return FALSE;
109 }
110
111 SidEntry = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WELL_KNOWN_SID));
112 if (SidEntry == NULL)
113 return FALSE;
114
115 InitializeListHead(&SidEntry->ListEntry);
116
117 SidEntry->Sid = RtlAllocateHeap(RtlGetProcessHeap(),
118 0,
119 RtlLengthRequiredSid(SubAuthorityCount));
120 if (SidEntry->Sid == NULL)
121 {
122 RtlFreeHeap(RtlGetProcessHeap(), 0, SidEntry);
123 return FALSE;
124 }
125
126 RtlInitializeSid(SidEntry->Sid,
127 IdentifierAuthority,
128 SubAuthorityCount);
129
130 for (i = 0; i < (ULONG)SubAuthorityCount; i++)
131 {
132 p = RtlSubAuthoritySid(SidEntry->Sid, i);
133 *p = SubAuthorities[i];
134 }
135
136// RtlInitUnicodeString(&SidEntry->AccountName,
137// AccountName);
138 SidEntry->AccountName.Length = (USHORT)AccountNameLength * sizeof(WCHAR);
139 SidEntry->AccountName.MaximumLength = SidEntry->AccountName.Length + sizeof(WCHAR);
140 SidEntry->AccountName.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0,
141 SidEntry->AccountName.MaximumLength);
142 if (SidEntry->AccountName.Buffer == NULL)
143 {
144 RtlFreeHeap(RtlGetProcessHeap(), 0, SidEntry->Sid);
145 RtlFreeHeap(RtlGetProcessHeap(), 0, SidEntry);
146 return FALSE;
147 }
148
149 wcscpy(SidEntry->AccountName.Buffer,
150 AccountName);
151
152// RtlInitUnicodeString(&SidEntry->DomainName,
153// DomainName);
154 SidEntry->DomainName.Length = (USHORT)DomainNameLength * sizeof(WCHAR);
155 SidEntry->DomainName.MaximumLength = SidEntry->DomainName.Length + sizeof(WCHAR);
156 SidEntry->DomainName.Buffer = RtlAllocateHeap(RtlGetProcessHeap(), 0,
157 SidEntry->DomainName.MaximumLength);
158 if (SidEntry->DomainName.Buffer == NULL)
159 {
160 RtlFreeHeap(RtlGetProcessHeap(), 0, SidEntry->AccountName.Buffer);
161 RtlFreeHeap(RtlGetProcessHeap(), 0, SidEntry->Sid);
162 RtlFreeHeap(RtlGetProcessHeap(), 0, SidEntry);
163 return FALSE;
164 }
165
166 wcscpy(SidEntry->DomainName.Buffer,
167 DomainName);
168
169 SidEntry->Use = Use;
170
171 InsertTailList(&WellKnownSidListHead,
172 &SidEntry->ListEntry);
173
174 if (SidPtr != NULL)
175 *SidPtr = SidEntry->Sid;
176
177 return TRUE;
178}
179
180
181NTSTATUS
182LsapInitSids(VOID)
183{
184 WCHAR szAccountName[80];
185 WCHAR szDomainName[80];
186 ULONG SubAuthorities[8];
187 HINSTANCE hInstance;
188
189 InitializeListHead(&WellKnownSidListHead);
190
191 hInstance = GetModuleHandleW(L"lsasrv.dll");
192
193 /* NT Authority */
194 LsapLoadString(hInstance, IDS_NT_AUTHORITY, szAccountName, ARRAYSIZE(szAccountName));
195 LsapLoadString(hInstance, IDS_NT_AUTHORITY, szDomainName, ARRAYSIZE(szDomainName));
196 LsapCreateSid(&NtAuthority,
197 0,
198 NULL,
199 szAccountName,
200 szDomainName,
201 SidTypeDomain,
202 NULL);
203
204 /* Null Sid */
205 LsapLoadString(hInstance, IDS_NULL_RID, szAccountName, ARRAYSIZE(szAccountName));
206
207 SubAuthorities[0] = SECURITY_NULL_RID;
208 LsapCreateSid(&NullSidAuthority,
209 1,
210 SubAuthorities,
211 szAccountName,
212 L"",
213 SidTypeWellKnownGroup,
214 NULL);
215
216 /* World Sid */
217 LsapLoadString(hInstance, IDS_WORLD_RID, szAccountName, ARRAYSIZE(szAccountName));
218
219 SubAuthorities[0] = SECURITY_WORLD_RID;
220 LsapCreateSid(&WorldSidAuthority,
221 1,
222 SubAuthorities,
223 szAccountName,
224 L"",
225 SidTypeWellKnownGroup,
226 &LsapWorldSid);
227
228 /* Local Sid */
229 LsapLoadString(hInstance, IDS_LOCAL_RID, szAccountName, ARRAYSIZE(szAccountName));
230
231 SubAuthorities[0] = SECURITY_LOCAL_RID;
232 LsapCreateSid(&LocalSidAuthority,
233 1,
234 SubAuthorities,
235 szAccountName,
236 L"",
237 SidTypeWellKnownGroup,
238 NULL);
239
240 /* Creator Owner Sid */
241 LsapLoadString(hInstance, IDS_CREATOR_OWNER_RID, szAccountName, ARRAYSIZE(szAccountName));
242
243 SubAuthorities[0] = SECURITY_CREATOR_OWNER_RID;
244 LsapCreateSid(&CreatorSidAuthority,
245 1,
246 SubAuthorities,
247 szAccountName,
248 L"",
249 SidTypeWellKnownGroup,
250 NULL);
251
252 /* Creator Group Sid */
253 LsapLoadString(hInstance, IDS_CREATOR_GROUP_RID, szAccountName, ARRAYSIZE(szAccountName));
254
255 SubAuthorities[0] = SECURITY_CREATOR_GROUP_RID;
256 LsapCreateSid(&CreatorSidAuthority,
257 1,
258 SubAuthorities,
259 szAccountName,
260 L"",
261 SidTypeWellKnownGroup,
262 NULL);
263
264 /* Creator Owner Server Sid */
265 LsapLoadString(hInstance, IDS_CREATOR_OWNER_SERVER_RID, szAccountName, ARRAYSIZE(szAccountName));
266
267 SubAuthorities[0] = SECURITY_CREATOR_OWNER_SERVER_RID;
268 LsapCreateSid(&CreatorSidAuthority,
269 1,
270 SubAuthorities,
271 szAccountName,
272 L"",
273 SidTypeWellKnownGroup,
274 NULL);
275
276 /* Creator Group Server Sid */
277 LsapLoadString(hInstance, IDS_CREATOR_GROUP_SERVER_RID, szAccountName, ARRAYSIZE(szAccountName));
278
279 SubAuthorities[0] = SECURITY_CREATOR_GROUP_SERVER_RID;
280 LsapCreateSid(&CreatorSidAuthority,
281 1,
282 SubAuthorities,
283 szAccountName,
284 L"",
285 SidTypeWellKnownGroup,
286 NULL);
287
288 /* Dialup Sid */
289 LsapLoadString(hInstance, IDS_DIALUP_RID, szAccountName, ARRAYSIZE(szAccountName));
290 LsapLoadString(hInstance, IDS_NT_AUTHORITY, szDomainName, ARRAYSIZE(szDomainName));
291
292 SubAuthorities[0] = SECURITY_DIALUP_RID;
293 LsapCreateSid(&NtAuthority,
294 1,
295 SubAuthorities,
296 szAccountName,
297 szDomainName,
298 SidTypeWellKnownGroup,
299 NULL);
300
301 /* Network Sid */
302 LsapLoadString(hInstance, IDS_NETWORK_RID, szAccountName, ARRAYSIZE(szAccountName));
303
304 SubAuthorities[0] = SECURITY_NETWORK_RID;
305 LsapCreateSid(&NtAuthority,
306 1,
307 SubAuthorities,
308 szAccountName,
309 szDomainName,
310 SidTypeWellKnownGroup,
311 &LsapNetworkSid);
312
313 /* Batch Sid*/
314 LsapLoadString(hInstance, IDS_BATCH_RID, szAccountName, ARRAYSIZE(szAccountName));
315
316 SubAuthorities[0] = SECURITY_BATCH_RID;
317 LsapCreateSid(&NtAuthority,
318 1,
319 SubAuthorities,
320 szAccountName,
321 szDomainName,
322 SidTypeWellKnownGroup,
323 &LsapBatchSid);
324
325 /* Interactive Sid */
326 LsapLoadString(hInstance, IDS_INTERACTIVE_RID, szAccountName, ARRAYSIZE(szAccountName));
327
328 SubAuthorities[0] = SECURITY_INTERACTIVE_RID;
329 LsapCreateSid(&NtAuthority,
330 1,
331 SubAuthorities,
332 szAccountName,
333 szDomainName,
334 SidTypeWellKnownGroup,
335 &LsapInteractiveSid);
336
337 /* Service Sid */
338 LsapLoadString(hInstance, IDS_SERVICE_RID, szAccountName, ARRAYSIZE(szAccountName));
339
340 SubAuthorities[0] = SECURITY_SERVICE_RID;
341 LsapCreateSid(&NtAuthority,
342 1,
343 SubAuthorities,
344 szAccountName,
345 szDomainName,
346 SidTypeWellKnownGroup,
347 &LsapServiceSid);
348
349 /* Anonymous Logon Sid */
350 LsapLoadString(hInstance, IDS_ANONYMOUS_LOGON_RID, szAccountName, ARRAYSIZE(szAccountName));
351
352 SubAuthorities[0] = SECURITY_ANONYMOUS_LOGON_RID;
353 LsapCreateSid(&NtAuthority,
354 1,
355 SubAuthorities,
356 szAccountName,
357 szDomainName,
358 SidTypeWellKnownGroup,
359 NULL);
360
361 /* Proxy Sid */
362 LsapLoadString(hInstance, IDS_PROXY_RID, szAccountName, ARRAYSIZE(szAccountName));
363
364 SubAuthorities[0] = SECURITY_PROXY_RID;
365 LsapCreateSid(&NtAuthority,
366 1,
367 SubAuthorities,
368 szAccountName,
369 szDomainName,
370 SidTypeWellKnownGroup,
371 NULL);
372
373 /* Enterprise Controllers Sid */
374 LsapLoadString(hInstance, IDS_ENTERPRISE_CONTROLLERS_RID, szAccountName, ARRAYSIZE(szAccountName));
375
376 SubAuthorities[0] = SECURITY_ENTERPRISE_CONTROLLERS_RID;
377 LsapCreateSid(&NtAuthority,
378 1,
379 SubAuthorities,
380 szAccountName,
381 szDomainName,
382 SidTypeWellKnownGroup,
383 NULL);
384
385 /* Principal Self Sid */
386 LsapLoadString(hInstance, IDS_PRINCIPAL_SELF_RID, szAccountName, ARRAYSIZE(szAccountName));
387
388 SubAuthorities[0] = SECURITY_PRINCIPAL_SELF_RID;
389 LsapCreateSid(&NtAuthority,
390 1,
391 SubAuthorities,
392 szAccountName,
393 szDomainName,
394 SidTypeWellKnownGroup,
395 NULL);
396
397 /* Authenticated Users Sid */
398 LsapLoadString(hInstance, IDS_AUTHENTICATED_USER_RID, szAccountName, ARRAYSIZE(szAccountName));
399
400 SubAuthorities[0] = SECURITY_AUTHENTICATED_USER_RID;
401 LsapCreateSid(&NtAuthority,
402 1,
403 SubAuthorities,
404 szAccountName,
405 szDomainName,
406 SidTypeWellKnownGroup,
407 NULL);
408
409 /* Restricted Code Sid */
410 LsapLoadString(hInstance, IDS_RESTRICTED_CODE_RID, szAccountName, ARRAYSIZE(szAccountName));
411
412 SubAuthorities[0] = SECURITY_RESTRICTED_CODE_RID;
413 LsapCreateSid(&NtAuthority,
414 1,
415 SubAuthorities,
416 szAccountName,
417 szDomainName,
418 SidTypeWellKnownGroup,
419 NULL);
420
421 /* Terminal Server Sid */
422 LsapLoadString(hInstance, IDS_TERMINAL_SERVER_RID, szAccountName, ARRAYSIZE(szAccountName));
423
424 SubAuthorities[0] = SECURITY_TERMINAL_SERVER_RID;
425 LsapCreateSid(&NtAuthority,
426 1,
427 SubAuthorities,
428 szAccountName,
429 szDomainName,
430 SidTypeWellKnownGroup,
431 NULL);
432
433 /* Remote Logon Sid */
434 LsapLoadString(hInstance, IDS_REMOTE_LOGON_RID, szAccountName, ARRAYSIZE(szAccountName));
435
436 SubAuthorities[0] = SECURITY_REMOTE_LOGON_RID;
437 LsapCreateSid(&NtAuthority,
438 1,
439 SubAuthorities,
440 szAccountName,
441 szDomainName,
442 SidTypeWellKnownGroup,
443 NULL);
444
445 /* This Organization Sid */
446 LsapLoadString(hInstance, IDS_THIS_ORGANIZATION_RID, szAccountName, ARRAYSIZE(szAccountName));
447
448 SubAuthorities[0] = SECURITY_THIS_ORGANIZATION_RID;
449 LsapCreateSid(&NtAuthority,
450 1,
451 SubAuthorities,
452 szAccountName,
453 szDomainName,
454 SidTypeWellKnownGroup,
455 NULL);
456
457 /* Local System Sid */
458 LsapLoadString(hInstance, IDS_LOCAL_SYSTEM_RID, szAccountName, ARRAYSIZE(szAccountName));
459
460 SubAuthorities[0] = SECURITY_LOCAL_SYSTEM_RID;
461 LsapCreateSid(&NtAuthority,
462 1,
463 SubAuthorities,
464 szAccountName,
465 szDomainName,
466 SidTypeWellKnownGroup,
467 &LsapLocalSystemSid);
468
469 /* Local Service Sid */
470 LsapLoadString(hInstance, IDS_LOCAL_SERVICE_RID, szAccountName, ARRAYSIZE(szAccountName));
471
472 SubAuthorities[0] = SECURITY_LOCAL_SERVICE_RID;
473 LsapCreateSid(&NtAuthority,
474 1,
475 SubAuthorities,
476 szAccountName,
477 szDomainName,
478 SidTypeWellKnownGroup,
479 NULL);
480
481 LsapCreateSid(&NtAuthority,
482 1,
483 SubAuthorities,
484 L"LOCALSERVICE",
485 L"NT AUTHORITY",
486 SidTypeWellKnownGroup,
487 NULL);
488
489 /* Network Service Sid */
490 LsapLoadString(hInstance, IDS_NETWORK_SERVICE_RID, szAccountName, ARRAYSIZE(szAccountName));
491
492 SubAuthorities[0] = SECURITY_NETWORK_SERVICE_RID;
493 LsapCreateSid(&NtAuthority,
494 1,
495 SubAuthorities,
496 szAccountName,
497 szDomainName,
498 SidTypeWellKnownGroup,
499 NULL);
500
501 LsapCreateSid(&NtAuthority,
502 1,
503 SubAuthorities,
504 L"NETWORKSERVICE",
505 L"NT AUTHORITY",
506 SidTypeWellKnownGroup,
507 NULL);
508
509 /* Builtin Domain Sid */
510 LsapLoadString(hInstance, IDS_BUILTIN_DOMAIN_RID, szAccountName, ARRAYSIZE(szAccountName));
511 LsapLoadString(hInstance, IDS_BUILTIN_DOMAIN_RID, szDomainName, ARRAYSIZE(szDomainName));
512
513 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
514 LsapCreateSid(&NtAuthority,
515 1,
516 SubAuthorities,
517 szAccountName,
518 szDomainName,
519 SidTypeDomain,
520 NULL);
521
522 /* Administrators Alias Sid */
523 LsapLoadString(hInstance, IDS_ALIAS_RID_ADMINS, szAccountName, ARRAYSIZE(szAccountName));
524
525 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
526 SubAuthorities[1] = DOMAIN_ALIAS_RID_ADMINS;
527 LsapCreateSid(&NtAuthority,
528 2,
529 SubAuthorities,
530 szAccountName,
531 szDomainName,
532 SidTypeAlias,
533 &LsapAdministratorsSid);
534
535 /* Users Alias Sid */
536 LsapLoadString(hInstance, IDS_ALIAS_RID_USERS, szAccountName, ARRAYSIZE(szAccountName));
537
538 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
539 SubAuthorities[1] = DOMAIN_ALIAS_RID_USERS;
540 LsapCreateSid(&NtAuthority,
541 2,
542 SubAuthorities,
543 szAccountName,
544 szDomainName,
545 SidTypeAlias,
546 NULL);
547
548 /* Guests Alias Sid */
549 LsapLoadString(hInstance, IDS_ALIAS_RID_GUESTS, szAccountName, ARRAYSIZE(szAccountName));
550
551 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
552 SubAuthorities[1] = DOMAIN_ALIAS_RID_GUESTS;
553 LsapCreateSid(&NtAuthority,
554 2,
555 SubAuthorities,
556 szAccountName,
557 szDomainName,
558 SidTypeAlias,
559 NULL);
560
561 /* Power User Alias Sid */
562 LsapLoadString(hInstance, IDS_ALIAS_RID_POWER_USERS, szAccountName, ARRAYSIZE(szAccountName));
563
564 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
565 SubAuthorities[1] = DOMAIN_ALIAS_RID_POWER_USERS;
566 LsapCreateSid(&NtAuthority,
567 2,
568 SubAuthorities,
569 szAccountName,
570 szDomainName,
571 SidTypeAlias,
572 NULL);
573
574 /* Account Operators Alias Sid */
575 LsapLoadString(hInstance, IDS_ALIAS_RID_ACCOUNT_OPS, szAccountName, ARRAYSIZE(szAccountName));
576
577 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
578 SubAuthorities[1] = DOMAIN_ALIAS_RID_ACCOUNT_OPS;
579 LsapCreateSid(&NtAuthority,
580 2,
581 SubAuthorities,
582 szAccountName,
583 szDomainName,
584 SidTypeAlias,
585 NULL);
586
587 /* System Operators Alias Sid */
588 LsapLoadString(hInstance, IDS_ALIAS_RID_SYSTEM_OPS, szAccountName, ARRAYSIZE(szAccountName));
589
590 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
591 SubAuthorities[1] = DOMAIN_ALIAS_RID_SYSTEM_OPS;
592 LsapCreateSid(&NtAuthority,
593 2,
594 SubAuthorities,
595 szAccountName,
596 szDomainName,
597 SidTypeAlias,
598 NULL);
599
600 /* Print Operators Alias Sid */
601 LsapLoadString(hInstance, IDS_ALIAS_RID_PRINT_OPS, szAccountName, ARRAYSIZE(szAccountName));
602
603 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
604 SubAuthorities[1] = DOMAIN_ALIAS_RID_PRINT_OPS;
605 LsapCreateSid(&NtAuthority,
606 2,
607 SubAuthorities,
608 szAccountName,
609 szDomainName,
610 SidTypeAlias,
611 NULL);
612
613 /* Backup Operators Alias Sid */
614 LsapLoadString(hInstance, IDS_ALIAS_RID_BACKUP_OPS, szAccountName, ARRAYSIZE(szAccountName));
615
616 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
617 SubAuthorities[1] = DOMAIN_ALIAS_RID_BACKUP_OPS;
618 LsapCreateSid(&NtAuthority,
619 2,
620 SubAuthorities,
621 szAccountName,
622 szDomainName,
623 SidTypeAlias,
624 NULL);
625
626 /* Replicators Alias Sid */
627 LsapLoadString(hInstance, IDS_ALIAS_RID_REPLICATOR, szAccountName, ARRAYSIZE(szAccountName));
628
629 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
630 SubAuthorities[1] = DOMAIN_ALIAS_RID_REPLICATOR;
631 LsapCreateSid(&NtAuthority,
632 2,
633 SubAuthorities,
634 szAccountName,
635 szDomainName,
636 SidTypeAlias,
637 NULL);
638
639 /* RAS Servers Alias Sid */
640 LsapLoadString(hInstance, IDS_ALIAS_RID_RAS_SERVERS, szAccountName, ARRAYSIZE(szAccountName));
641
642 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
643 SubAuthorities[1] = DOMAIN_ALIAS_RID_RAS_SERVERS;
644 LsapCreateSid(&NtAuthority,
645 2,
646 SubAuthorities,
647 szAccountName,
648 szDomainName,
649 SidTypeAlias,
650 NULL);
651
652 /* Pre-Windows 2000 Compatible Access Alias Sid */
653 LsapLoadString(hInstance, IDS_ALIAS_RID_PREW2KCOMPACCESS, szAccountName, ARRAYSIZE(szAccountName));
654
655 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
656 SubAuthorities[1] = DOMAIN_ALIAS_RID_PREW2KCOMPACCESS;
657 LsapCreateSid(&NtAuthority,
658 2,
659 SubAuthorities,
660 szAccountName,
661 szDomainName,
662 SidTypeAlias,
663 NULL);
664
665 /* Remote Desktop Users Alias Sid */
666 LsapLoadString(hInstance, IDS_ALIAS_RID_REMOTE_DESKTOP_USERS, szAccountName, ARRAYSIZE(szAccountName));
667
668 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
669 SubAuthorities[1] = DOMAIN_ALIAS_RID_REMOTE_DESKTOP_USERS;
670 LsapCreateSid(&NtAuthority,
671 2,
672 SubAuthorities,
673 szAccountName,
674 szDomainName,
675 SidTypeAlias,
676 NULL);
677
678 /* Network Configuration Operators Alias Sid */
679 LsapLoadString(hInstance, IDS_ALIAS_RID_NETWORK_CONFIGURATION_OPS, szAccountName, ARRAYSIZE(szAccountName));
680
681 SubAuthorities[0] = SECURITY_BUILTIN_DOMAIN_RID;
682 SubAuthorities[1] = DOMAIN_ALIAS_RID_NETWORK_CONFIGURATION_OPS;
683 LsapCreateSid(&NtAuthority,
684 2,
685 SubAuthorities,
686 szAccountName,
687 szDomainName,
688 SidTypeAlias,
689 NULL);
690
691 /* FIXME: Add more well known sids */
692
693 return STATUS_SUCCESS;
694}
695
696
697PWELL_KNOWN_SID
698LsapLookupWellKnownSid(PSID Sid)
699{
700 PLIST_ENTRY ListEntry;
701 PWELL_KNOWN_SID Ptr;
702
703 ListEntry = WellKnownSidListHead.Flink;
704 while (ListEntry != &WellKnownSidListHead)
705 {
706 Ptr = CONTAINING_RECORD(ListEntry,
707 WELL_KNOWN_SID,
708 ListEntry);
709 if (RtlEqualSid(Sid, Ptr->Sid))
710 {
711 return Ptr;
712 }
713
714 ListEntry = ListEntry->Flink;
715 }
716
717 return NULL;
718}
719
720
721PWELL_KNOWN_SID
722LsapLookupIsolatedWellKnownName(PUNICODE_STRING AccountName)
723{
724 PLIST_ENTRY ListEntry;
725 PWELL_KNOWN_SID Ptr;
726
727 ListEntry = WellKnownSidListHead.Flink;
728 while (ListEntry != &WellKnownSidListHead)
729 {
730 Ptr = CONTAINING_RECORD(ListEntry,
731 WELL_KNOWN_SID,
732 ListEntry);
733 if (RtlEqualUnicodeString(AccountName, &Ptr->AccountName, TRUE))
734 {
735 return Ptr;
736 }
737
738 ListEntry = ListEntry->Flink;
739 }
740
741 return NULL;
742}
743
744
745PWELL_KNOWN_SID
746LsapLookupFullyQualifiedWellKnownName(PUNICODE_STRING AccountName,
747 PUNICODE_STRING DomainName)
748{
749 PLIST_ENTRY ListEntry;
750 PWELL_KNOWN_SID Ptr;
751
752 ListEntry = WellKnownSidListHead.Flink;
753 while (ListEntry != &WellKnownSidListHead)
754 {
755 Ptr = CONTAINING_RECORD(ListEntry,
756 WELL_KNOWN_SID,
757 ListEntry);
758 if (RtlEqualUnicodeString(AccountName, &Ptr->AccountName, TRUE) &&
759 RtlEqualUnicodeString(DomainName, &Ptr->DomainName, TRUE))
760 {
761 return Ptr;
762 }
763
764 ListEntry = ListEntry->Flink;
765 }
766
767 return NULL;
768}
769
770
771static
772NTSTATUS
773LsapSplitNames(DWORD Count,
774 PRPC_UNICODE_STRING Names,
775 PRPC_UNICODE_STRING *DomainNames,
776 PRPC_UNICODE_STRING *AccountNames)
777{
778 PRPC_UNICODE_STRING DomainsBuffer = NULL;
779 PRPC_UNICODE_STRING AccountsBuffer = NULL;
780 ULONG DomainLength;
781 ULONG AccountLength;
782 ULONG i;
783 LPWSTR Ptr;
784 NTSTATUS Status = STATUS_SUCCESS;
785
786 DomainsBuffer = MIDL_user_allocate(Count * sizeof(RPC_UNICODE_STRING));
787 if (DomainsBuffer == NULL)
788 {
789 Status = STATUS_INSUFFICIENT_RESOURCES;
790 goto done;
791 }
792
793 AccountsBuffer = MIDL_user_allocate(Count * sizeof(RPC_UNICODE_STRING));
794 if (AccountsBuffer == NULL)
795 {
796 Status = STATUS_INSUFFICIENT_RESOURCES;
797 goto done;
798 }
799
800 for (i = 0; i < Count; i++)
801 {
802//TRACE("Name: %wZ\n", &Names[i]);
803
804 Ptr = wcschr(Names[i].Buffer, L'\\');
805 if (Ptr == NULL)
806 {
807 AccountLength = Names[i].Length / sizeof(WCHAR);
808
809 AccountsBuffer[i].Length = Names[i].Length;
810 AccountsBuffer[i].MaximumLength = AccountsBuffer[i].Length + sizeof(WCHAR);
811 AccountsBuffer[i].Buffer = MIDL_user_allocate(AccountsBuffer[i].MaximumLength);
812 if (AccountsBuffer[i].Buffer == NULL)
813 {
814 Status = STATUS_INSUFFICIENT_RESOURCES;
815 goto done;
816 }
817
818 CopyMemory(AccountsBuffer[i].Buffer,
819 Names[i].Buffer,
820 AccountsBuffer[i].Length);
821 AccountsBuffer[i].Buffer[AccountLength] = UNICODE_NULL;
822
823//TRACE("Account name: %wZ\n", &AccountsBuffer[i]);
824 }
825 else
826 {
827 DomainLength = (ULONG)(ULONG_PTR)(Ptr - Names[i].Buffer);
828 AccountLength = (Names[i].Length / sizeof(WCHAR)) - DomainLength - 1;
829//TRACE("DomainLength: %u\n", DomainLength);
830//TRACE("AccountLength: %u\n", AccountLength);
831
832 if (DomainLength > 0)
833 {
834 DomainsBuffer[i].Length = (USHORT)DomainLength * sizeof(WCHAR);
835 DomainsBuffer[i].MaximumLength = DomainsBuffer[i].Length + sizeof(WCHAR);
836 DomainsBuffer[i].Buffer = MIDL_user_allocate(DomainsBuffer[i].MaximumLength);
837 if (DomainsBuffer[i].Buffer == NULL)
838 {
839 Status = STATUS_INSUFFICIENT_RESOURCES;
840 goto done;
841 }
842
843 CopyMemory(DomainsBuffer[i].Buffer,
844 Names[i].Buffer,
845 DomainsBuffer[i].Length);
846 DomainsBuffer[i].Buffer[DomainLength] = UNICODE_NULL;
847
848//TRACE("Domain name: %wZ\n", &DomainsBuffer[i]);
849 }
850
851 AccountsBuffer[i].Length = (USHORT)AccountLength * sizeof(WCHAR);
852 AccountsBuffer[i].MaximumLength = AccountsBuffer[i].Length + sizeof(WCHAR);
853 AccountsBuffer[i].Buffer = MIDL_user_allocate(AccountsBuffer[i].MaximumLength);
854 if (AccountsBuffer[i].Buffer == NULL)
855 {
856 Status = STATUS_INSUFFICIENT_RESOURCES;
857 goto done;
858 }
859
860 CopyMemory(AccountsBuffer[i].Buffer,
861 &(Names[i].Buffer[DomainLength + 1]),
862 AccountsBuffer[i].Length);
863 AccountsBuffer[i].Buffer[AccountLength] = UNICODE_NULL;
864
865//TRACE("Account name: %wZ\n", &AccountsBuffer[i]);
866 }
867 }
868
869done:
870 if (!NT_SUCCESS(Status))
871 {
872 if (AccountsBuffer != NULL)
873 {
874 for (i = 0; i < Count; i++)
875 {
876 if (AccountsBuffer[i].Buffer != NULL)
877 MIDL_user_free(AccountsBuffer[i].Buffer);
878 }
879
880 MIDL_user_free(AccountsBuffer);
881 }
882
883 if (DomainsBuffer != NULL)
884 {
885 for (i = 0; i < Count; i++)
886 {
887 if (DomainsBuffer[i].Buffer != NULL)
888 MIDL_user_free(DomainsBuffer[i].Buffer);
889 }
890
891 MIDL_user_free(DomainsBuffer);
892 }
893 }
894 else
895 {
896 *DomainNames = DomainsBuffer;
897 *AccountNames = AccountsBuffer;
898 }
899
900 return Status;
901}
902
903
904static NTSTATUS
905LsapAddDomainToDomainsList(PLSAPR_REFERENCED_DOMAIN_LIST ReferencedDomains,
906 PUNICODE_STRING Name,
907 PSID Sid,
908 PULONG Index)
909{
910 ULONG i;
911
912 i = 0;
913 while (i < ReferencedDomains->Entries &&
914 ReferencedDomains->Domains[i].Sid != NULL)
915 {
916 if (RtlEqualSid(Sid, ReferencedDomains->Domains[i].Sid))
917 {
918 *Index = i;
919 return STATUS_SUCCESS;
920 }
921
922 i++;
923 }
924
925 ReferencedDomains->Domains[i].Sid = MIDL_user_allocate(RtlLengthSid(Sid));
926 if (ReferencedDomains->Domains[i].Sid == NULL)
927 return STATUS_INSUFFICIENT_RESOURCES;
928
929 RtlCopySid(RtlLengthSid(Sid), ReferencedDomains->Domains[i].Sid, Sid);
930
931 ReferencedDomains->Domains[i].Name.Length = Name->Length;
932 ReferencedDomains->Domains[i].Name.MaximumLength = Name->MaximumLength;
933 ReferencedDomains->Domains[i].Name.Buffer = MIDL_user_allocate(Name->MaximumLength);
934 if (ReferencedDomains->Domains[i].Name.Buffer == NULL)
935 {
936 MIDL_user_free(ReferencedDomains->Domains[i].Sid);
937 ReferencedDomains->Domains[i].Sid = NULL;
938 return STATUS_INSUFFICIENT_RESOURCES;
939 }
940
941 RtlCopyMemory(ReferencedDomains->Domains[i].Name.Buffer,
942 Name->Buffer,
943 Name->MaximumLength);
944
945 ReferencedDomains->Entries++;
946 *Index = i;
947
948 return STATUS_SUCCESS;
949}
950
951
952static NTSTATUS
953LsapAddAuthorityToDomainsList(
954 PLSAPR_REFERENCED_DOMAIN_LIST ReferencedDomains,
955 PSID Sid,
956 PULONG Index)
957{
958 SID AuthoritySid;
959 ULONG i;
960
961 RtlInitializeSid(&AuthoritySid,
962 RtlIdentifierAuthoritySid(Sid),
963 0);
964
965 i = 0;
966 while (i < ReferencedDomains->Entries &&
967 ReferencedDomains->Domains[i].Sid != NULL)
968 {
969 if (RtlEqualSid(&AuthoritySid, ReferencedDomains->Domains[i].Sid))
970 {
971 *Index = i;
972 return STATUS_SUCCESS;
973 }
974
975 i++;
976 }
977
978 ReferencedDomains->Domains[i].Sid = MIDL_user_allocate(RtlLengthSid(&AuthoritySid));
979 if (ReferencedDomains->Domains[i].Sid == NULL)
980 return STATUS_INSUFFICIENT_RESOURCES;
981
982 RtlCopySid(RtlLengthSid(&AuthoritySid), ReferencedDomains->Domains[i].Sid, &AuthoritySid);
983
984 ReferencedDomains->Domains[i].Name.Length = 0;
985 ReferencedDomains->Domains[i].Name.MaximumLength = sizeof(WCHAR);
986 ReferencedDomains->Domains[i].Name.Buffer = MIDL_user_allocate(sizeof(WCHAR));
987 if (ReferencedDomains->Domains[i].Name.Buffer == NULL)
988 {
989 MIDL_user_free(ReferencedDomains->Domains[i].Sid);
990 ReferencedDomains->Domains[i].Sid = NULL;
991 return STATUS_INSUFFICIENT_RESOURCES;
992 }
993
994 ReferencedDomains->Domains[i].Name.Buffer[0] = UNICODE_NULL;
995
996 ReferencedDomains->Entries++;
997 *Index = i;
998
999 return STATUS_SUCCESS;
1000}
1001
1002
1003static BOOLEAN
1004LsapIsPrefixSid(IN PSID PrefixSid,
1005 IN PSID Sid)
1006{
1007 PISID Sid1 = PrefixSid, Sid2 = Sid;
1008 ULONG i;
1009
1010 if (Sid1->Revision != Sid2->Revision)
1011 return FALSE;
1012
1013 if ((Sid1->IdentifierAuthority.Value[0] != Sid2->IdentifierAuthority.Value[0]) ||
1014 (Sid1->IdentifierAuthority.Value[1] != Sid2->IdentifierAuthority.Value[1]) ||
1015 (Sid1->IdentifierAuthority.Value[2] != Sid2->IdentifierAuthority.Value[2]) ||
1016 (Sid1->IdentifierAuthority.Value[3] != Sid2->IdentifierAuthority.Value[3]) ||
1017 (Sid1->IdentifierAuthority.Value[4] != Sid2->IdentifierAuthority.Value[4]) ||
1018 (Sid1->IdentifierAuthority.Value[5] != Sid2->IdentifierAuthority.Value[5]))
1019 return FALSE;
1020
1021 if (Sid1->SubAuthorityCount >= Sid2->SubAuthorityCount)
1022 return FALSE;
1023
1024 if (Sid1->SubAuthorityCount == 0)
1025 return TRUE;
1026
1027 for (i = 0; i < Sid1->SubAuthorityCount; i++)
1028 {
1029 if (Sid1->SubAuthority[i] != Sid2->SubAuthority[i])
1030 return FALSE;
1031 }
1032
1033 return TRUE;
1034}
1035
1036
1037ULONG
1038LsapGetRelativeIdFromSid(PSID Sid_)
1039{
1040 PISID Sid = Sid_;
1041
1042 if (Sid->SubAuthorityCount != 0)
1043 return Sid->SubAuthority[Sid->SubAuthorityCount - 1];
1044
1045 return 0;
1046}
1047
1048
1049static PSID
1050CreateSidFromSidAndRid(PSID SrcSid,
1051 ULONG RelativeId)
1052{
1053 UCHAR RidCount;
1054 PSID DstSid;
1055 ULONG i;
1056 ULONG DstSidSize;
1057 PULONG p, q;
1058
1059 RidCount = *RtlSubAuthorityCountSid(SrcSid);
1060 if (RidCount >= 8)
1061 return NULL;
1062
1063 DstSidSize = RtlLengthRequiredSid(RidCount + 1);
1064
1065 DstSid = MIDL_user_allocate(DstSidSize);
1066 if (DstSid == NULL)
1067 return NULL;
1068
1069 RtlInitializeSid(DstSid,
1070 RtlIdentifierAuthoritySid(SrcSid),
1071 RidCount + 1);
1072
1073 for (i = 0; i < (ULONG)RidCount; i++)
1074 {
1075 p = RtlSubAuthoritySid(SrcSid, i);
1076 q = RtlSubAuthoritySid(DstSid, i);
1077 *q = *p;
1078 }
1079
1080 q = RtlSubAuthoritySid(DstSid, (ULONG)RidCount);
1081 *q = RelativeId;
1082
1083 return DstSid;
1084}
1085
1086
1087static PSID
1088CreateDomainSidFromAccountSid(PSID AccountSid)
1089{
1090 UCHAR RidCount;
1091 PSID DomainSid;
1092 ULONG i;
1093 ULONG DstSidSize;
1094 PULONG p, q;
1095
1096 RidCount = *RtlSubAuthorityCountSid(AccountSid);
1097 if (RidCount > 0)
1098 RidCount--;
1099
1100 DstSidSize = RtlLengthRequiredSid(RidCount);
1101
1102 DomainSid = MIDL_user_allocate(DstSidSize);
1103 if (DomainSid == NULL)
1104 return NULL;
1105
1106 RtlInitializeSid(DomainSid,
1107 RtlIdentifierAuthoritySid(AccountSid),
1108 RidCount);
1109
1110 for (i = 0; i < (ULONG)RidCount; i++)
1111 {
1112 p = RtlSubAuthoritySid(AccountSid, i);
1113 q = RtlSubAuthoritySid(DomainSid, i);
1114 *q = *p;
1115 }
1116
1117 return DomainSid;
1118}
1119
1120
1121static PSID
1122LsapCopySid(PSID SrcSid)
1123{
1124 UCHAR RidCount;
1125 PSID DstSid;
1126 ULONG i;
1127 ULONG DstSidSize;
1128 PULONG p, q;
1129
1130 RidCount = *RtlSubAuthorityCountSid(SrcSid);
1131 DstSidSize = RtlLengthRequiredSid(RidCount);
1132
1133 DstSid = MIDL_user_allocate(DstSidSize);
1134 if (DstSid == NULL)
1135 return NULL;
1136
1137 RtlInitializeSid(DstSid,
1138 RtlIdentifierAuthoritySid(SrcSid),
1139 RidCount);
1140
1141 for (i = 0; i < (ULONG)RidCount; i++)
1142 {
1143 p = RtlSubAuthoritySid(SrcSid, i);
1144 q = RtlSubAuthoritySid(DstSid, i);
1145 *q = *p;
1146 }
1147
1148 return DstSid;
1149}
1150
1151
1152static
1153NTSTATUS
1154LsapLookupIsolatedNames(DWORD Count,
1155 PRPC_UNICODE_STRING DomainNames,
1156 PRPC_UNICODE_STRING AccountNames,
1157 PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer,
1158 PLSAPR_TRANSLATED_SID_EX2 SidsBuffer,
1159 PULONG Mapped)
1160{
1161 UNICODE_STRING EmptyDomainName = RTL_CONSTANT_STRING(L"");
1162 PWELL_KNOWN_SID ptr, ptr2;
1163 PSID DomainSid;
1164 ULONG DomainIndex;
1165 ULONG i;
1166 NTSTATUS Status = STATUS_SUCCESS;
1167
1168 for (i = 0; i < Count; i++)
1169 {
1170 /* Ignore names which were already mapped */
1171 if (SidsBuffer[i].Use != SidTypeUnknown)
1172 continue;
1173
1174 /* Ignore fully qualified account names */
1175 if (DomainNames[i].Length != 0)
1176 continue;
1177
1178 TRACE("Mapping name: %wZ\n", &AccountNames[i]);
1179
1180 /* Look-up all well-known names */
1181 ptr = LsapLookupIsolatedWellKnownName((PUNICODE_STRING)&AccountNames[i]);
1182 if (ptr != NULL)
1183 {
1184 SidsBuffer[i].Use = ptr->Use;
1185 SidsBuffer[i].Sid = LsapCopySid(ptr->Sid);
1186 if (SidsBuffer[i].Sid == NULL)
1187 {
1188 Status = STATUS_INSUFFICIENT_RESOURCES;
1189 goto done;
1190 }
1191
1192 SidsBuffer[i].DomainIndex = -1;
1193 SidsBuffer[i].Flags = 0;
1194
1195 if (ptr->Use == SidTypeDomain)
1196 {
1197 Status = LsapAddDomainToDomainsList(DomainsBuffer,
1198 &ptr->AccountName,
1199 ptr->Sid,
1200 &DomainIndex);
1201 if (!NT_SUCCESS(Status))
1202 goto done;
1203
1204 SidsBuffer[i].DomainIndex = DomainIndex;
1205 }
1206 else
1207 {
1208 ptr2= LsapLookupIsolatedWellKnownName(&ptr->DomainName);
1209 if (ptr2 != NULL)
1210 {
1211 Status = LsapAddDomainToDomainsList(DomainsBuffer,
1212 &ptr2->AccountName,
1213 ptr2->Sid,
1214 &DomainIndex);
1215 if (!NT_SUCCESS(Status))
1216 goto done;
1217
1218 SidsBuffer[i].DomainIndex = DomainIndex;
1219 }
1220 else
1221 {
1222 DomainSid = CreateDomainSidFromAccountSid(ptr->Sid);
1223 if (DomainSid == NULL)
1224 {
1225 Status = STATUS_INSUFFICIENT_RESOURCES;
1226 goto done;
1227 }
1228
1229 Status = LsapAddDomainToDomainsList(DomainsBuffer,
1230 &EmptyDomainName,
1231 DomainSid,
1232 &DomainIndex);
1233
1234 if (DomainSid != NULL)
1235 {
1236 MIDL_user_free(DomainSid);
1237 DomainSid = NULL;
1238 }
1239
1240 if (!NT_SUCCESS(Status))
1241 goto done;
1242
1243 SidsBuffer[i].DomainIndex = DomainIndex;
1244 }
1245 }
1246
1247 (*Mapped)++;
1248 continue;
1249 }
1250
1251 /* Look-up the built-in domain */
1252 if (RtlEqualUnicodeString((PUNICODE_STRING)&AccountNames[i], &BuiltinDomainName, TRUE))
1253 {
1254 SidsBuffer[i].Use = SidTypeDomain;
1255 SidsBuffer[i].Sid = LsapCopySid(BuiltinDomainSid);
1256 if (SidsBuffer[i].Sid == NULL)
1257 {
1258 Status = STATUS_INSUFFICIENT_RESOURCES;
1259 goto done;
1260 }
1261
1262 SidsBuffer[i].DomainIndex = -1;
1263 SidsBuffer[i].Flags = 0;
1264
1265 Status = LsapAddDomainToDomainsList(DomainsBuffer,
1266 &BuiltinDomainName,
1267 BuiltinDomainSid,
1268 &DomainIndex);
1269 if (!NT_SUCCESS(Status))
1270 goto done;
1271
1272 SidsBuffer[i].DomainIndex = DomainIndex;
1273
1274 (*Mapped)++;
1275 continue;
1276 }
1277
1278 /* Look-up the account domain */
1279 if (RtlEqualUnicodeString((PUNICODE_STRING)&AccountNames[i], &AccountDomainName, TRUE))
1280 {
1281 SidsBuffer[i].Use = SidTypeDomain;
1282 SidsBuffer[i].Sid = LsapCopySid(AccountDomainSid);
1283 if (SidsBuffer[i].Sid == NULL)
1284 {
1285 Status = STATUS_INSUFFICIENT_RESOURCES;
1286 goto done;
1287 }
1288 SidsBuffer[i].DomainIndex = -1;
1289 SidsBuffer[i].Flags = 0;
1290
1291 Status = LsapAddDomainToDomainsList(DomainsBuffer,
1292 &AccountDomainName,
1293 AccountDomainSid,
1294 &DomainIndex);
1295 if (!NT_SUCCESS(Status))
1296 goto done;
1297
1298 SidsBuffer[i].DomainIndex = DomainIndex;
1299
1300 (*Mapped)++;
1301 continue;
1302 }
1303
1304 /* FIXME: Look-up the primary domain */
1305
1306 /* FIXME: Look-up the trusted domains */
1307
1308 }
1309
1310done:
1311
1312 return Status;
1313}
1314
1315
1316static
1317NTSTATUS
1318LsapLookupIsolatedBuiltinNames(DWORD Count,
1319 PRPC_UNICODE_STRING DomainNames,
1320 PRPC_UNICODE_STRING AccountNames,
1321 PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer,
1322 PLSAPR_TRANSLATED_SID_EX2 SidsBuffer,
1323 PULONG Mapped)
1324{
1325 SAMPR_HANDLE ServerHandle = NULL;
1326 SAMPR_HANDLE DomainHandle = NULL;
1327 SAMPR_ULONG_ARRAY RelativeIds = {0, NULL};
1328 SAMPR_ULONG_ARRAY Use = {0, NULL};
1329 ULONG DomainIndex;
1330 ULONG i;
1331 NTSTATUS Status = STATUS_SUCCESS;
1332
1333 Status = SamrConnect(NULL,
1334 &ServerHandle,
1335 SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN);
1336 if (!NT_SUCCESS(Status))
1337 {
1338 TRACE("SamrConnect failed (Status %08lx)\n", Status);
1339 goto done;
1340 }
1341
1342 Status = SamrOpenDomain(ServerHandle,
1343 DOMAIN_LOOKUP,
1344 BuiltinDomainSid,
1345 &DomainHandle);
1346 if (!NT_SUCCESS(Status))
1347 {
1348 TRACE("SamOpenDomain failed (Status %08lx)\n", Status);
1349 goto done;
1350 }
1351
1352 for (i = 0; i < Count; i++)
1353 {
1354 /* Ignore names which were already mapped */
1355 if (SidsBuffer[i].Use != SidTypeUnknown)
1356 continue;
1357
1358 /* Ignore fully qualified account names */
1359 if (DomainNames[i].Length != 0)
1360 continue;
1361
1362 TRACE("Mapping name: %wZ\n", &AccountNames[i]);
1363
1364 Status = SamrLookupNamesInDomain(DomainHandle,
1365 1,
1366 &AccountNames[i],
1367 &RelativeIds,
1368 &Use);
1369 if (NT_SUCCESS(Status))
1370 {
1371 TRACE("Found relative ID: %lu\n", RelativeIds.Element[0]);
1372
1373 SidsBuffer[i].Use = Use.Element[0];
1374 SidsBuffer[i].Sid = CreateSidFromSidAndRid(BuiltinDomainSid,
1375 RelativeIds.Element[0]);
1376 if (SidsBuffer[i].Sid == NULL)
1377 {
1378 Status = STATUS_INSUFFICIENT_RESOURCES;
1379 goto done;
1380 }
1381
1382 SidsBuffer[i].DomainIndex = -1;
1383 SidsBuffer[i].Flags = 0;
1384
1385 Status = LsapAddDomainToDomainsList(DomainsBuffer,
1386 &BuiltinDomainName,
1387 BuiltinDomainSid,
1388 &DomainIndex);
1389 if (!NT_SUCCESS(Status))
1390 goto done;
1391
1392 SidsBuffer[i].DomainIndex = DomainIndex;
1393
1394 (*Mapped)++;
1395 }
1396
1397 SamIFree_SAMPR_ULONG_ARRAY(&RelativeIds);
1398 SamIFree_SAMPR_ULONG_ARRAY(&Use);
1399 }
1400
1401done:
1402 if (DomainHandle != NULL)
1403 SamrCloseHandle(&DomainHandle);
1404
1405 if (ServerHandle != NULL)
1406 SamrCloseHandle(&ServerHandle);
1407
1408 return Status;
1409}
1410
1411
1412static
1413NTSTATUS
1414LsapLookupIsolatedAccountNames(DWORD Count,
1415 PRPC_UNICODE_STRING DomainNames,
1416 PRPC_UNICODE_STRING AccountNames,
1417 PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer,
1418 PLSAPR_TRANSLATED_SID_EX2 SidsBuffer,
1419 PULONG Mapped)
1420{
1421 SAMPR_HANDLE ServerHandle = NULL;
1422 SAMPR_HANDLE DomainHandle = NULL;
1423 SAMPR_ULONG_ARRAY RelativeIds = {0, NULL};
1424 SAMPR_ULONG_ARRAY Use = {0, NULL};
1425 ULONG DomainIndex;
1426 ULONG i;
1427 NTSTATUS Status = STATUS_SUCCESS;
1428
1429 TRACE("()\n");
1430
1431 Status = SamrConnect(NULL,
1432 &ServerHandle,
1433 SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN);
1434 if (!NT_SUCCESS(Status))
1435 {
1436 TRACE("SamrConnect failed (Status %08lx)\n", Status);
1437 goto done;
1438 }
1439
1440 Status = SamrOpenDomain(ServerHandle,
1441 DOMAIN_LOOKUP,
1442 AccountDomainSid,
1443 &DomainHandle);
1444 if (!NT_SUCCESS(Status))
1445 {
1446 TRACE("SamOpenDomain failed (Status %08lx)\n", Status);
1447 goto done;
1448 }
1449
1450 for (i = 0; i < Count; i++)
1451 {
1452 /* Ignore names which were already mapped */
1453 if (SidsBuffer[i].Use != SidTypeUnknown)
1454 continue;
1455
1456 /* Ignore fully qualified account names */
1457 if (DomainNames[i].Length != 0)
1458 continue;
1459
1460 TRACE("Mapping name: %wZ\n", &AccountNames[i]);
1461
1462 Status = SamrLookupNamesInDomain(DomainHandle,
1463 1,
1464 &AccountNames[i],
1465 &RelativeIds,
1466 &Use);
1467 if (NT_SUCCESS(Status))
1468 {
1469 TRACE("Found relative ID: %lu\n", RelativeIds.Element[0]);
1470
1471 SidsBuffer[i].Use = Use.Element[0];
1472 SidsBuffer[i].Sid = CreateSidFromSidAndRid(AccountDomainSid,
1473 RelativeIds.Element[0]);
1474 if (SidsBuffer[i].Sid == NULL)
1475 {
1476 Status = STATUS_INSUFFICIENT_RESOURCES;
1477 goto done;
1478 }
1479
1480 SidsBuffer[i].DomainIndex = -1;
1481 SidsBuffer[i].Flags = 0;
1482
1483 Status = LsapAddDomainToDomainsList(DomainsBuffer,
1484 &AccountDomainName,
1485 AccountDomainSid,
1486 &DomainIndex);
1487 if (!NT_SUCCESS(Status))
1488 goto done;
1489
1490 SidsBuffer[i].DomainIndex = DomainIndex;
1491
1492 (*Mapped)++;
1493 }
1494
1495 SamIFree_SAMPR_ULONG_ARRAY(&RelativeIds);
1496 SamIFree_SAMPR_ULONG_ARRAY(&Use);
1497 }
1498
1499done:
1500 if (DomainHandle != NULL)
1501 SamrCloseHandle(&DomainHandle);
1502
1503 if (ServerHandle != NULL)
1504 SamrCloseHandle(&ServerHandle);
1505
1506 return Status;
1507}
1508
1509
1510static
1511NTSTATUS
1512LsapLookupFullyQualifiedWellKnownNames(DWORD Count,
1513 PRPC_UNICODE_STRING DomainNames,
1514 PRPC_UNICODE_STRING AccountNames,
1515 PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer,
1516 PLSAPR_TRANSLATED_SID_EX2 SidsBuffer,
1517 PULONG Mapped)
1518{
1519 UNICODE_STRING EmptyDomainName = RTL_CONSTANT_STRING(L"");
1520 PWELL_KNOWN_SID ptr, ptr2;
1521 PSID DomainSid;
1522 ULONG DomainIndex;
1523 ULONG i;
1524 NTSTATUS Status = STATUS_SUCCESS;
1525
1526 for (i = 0; i < Count; i++)
1527 {
1528 /* Ignore names which were already mapped */
1529 if (SidsBuffer[i].Use != SidTypeUnknown)
1530 continue;
1531
1532 /* Ignore isolated account names */
1533 if (DomainNames[i].Length == 0)
1534 continue;
1535
1536 TRACE("Mapping name: %wZ\\%wZ\n", &DomainNames[i], &AccountNames[i]);
1537
1538 /* Look-up all well-known names */
1539 ptr = LsapLookupFullyQualifiedWellKnownName((PUNICODE_STRING)&AccountNames[i],
1540 (PUNICODE_STRING)&DomainNames[i]);
1541 if (ptr != NULL)
1542 {
1543 TRACE("Found it! (%wZ\\%wZ)\n", &ptr->DomainName, &ptr->AccountName);
1544
1545 SidsBuffer[i].Use = ptr->Use;
1546 SidsBuffer[i].Sid = LsapCopySid(ptr->Sid);
1547 if (SidsBuffer[i].Sid == NULL)
1548 {
1549 Status = STATUS_INSUFFICIENT_RESOURCES;
1550 goto done;
1551 }
1552
1553 SidsBuffer[i].DomainIndex = -1;
1554 SidsBuffer[i].Flags = 0;
1555
1556 if (ptr->Use == SidTypeDomain)
1557 {
1558 Status = LsapAddDomainToDomainsList(DomainsBuffer,
1559 &ptr->AccountName,
1560 ptr->Sid,
1561 &DomainIndex);
1562 if (!NT_SUCCESS(Status))
1563 goto done;
1564
1565 SidsBuffer[i].DomainIndex = DomainIndex;
1566 }
1567 else
1568 {
1569 ptr2= LsapLookupIsolatedWellKnownName(&ptr->DomainName);
1570 if (ptr2 != NULL)
1571 {
1572 Status = LsapAddDomainToDomainsList(DomainsBuffer,
1573 &ptr2->AccountName,
1574 ptr2->Sid,
1575 &DomainIndex);
1576 if (!NT_SUCCESS(Status))
1577 goto done;
1578
1579 SidsBuffer[i].DomainIndex = DomainIndex;
1580 }
1581 else
1582 {
1583 DomainSid = CreateDomainSidFromAccountSid(ptr->Sid);
1584 if (DomainSid == NULL)
1585 {
1586 Status = STATUS_INSUFFICIENT_RESOURCES;
1587 goto done;
1588 }
1589
1590 Status = LsapAddDomainToDomainsList(DomainsBuffer,
1591 &EmptyDomainName,
1592 DomainSid,
1593 &DomainIndex);
1594
1595 if (DomainSid != NULL)
1596 {
1597 MIDL_user_free(DomainSid);
1598 DomainSid = NULL;
1599 }
1600
1601 if (!NT_SUCCESS(Status))
1602 goto done;
1603
1604 SidsBuffer[i].DomainIndex = DomainIndex;
1605 }
1606 }
1607
1608 (*Mapped)++;
1609 continue;
1610 }
1611 }
1612
1613done:
1614 return Status;
1615}
1616
1617
1618static
1619NTSTATUS
1620LsapLookupBuiltinNames(DWORD Count,
1621 PRPC_UNICODE_STRING DomainNames,
1622 PRPC_UNICODE_STRING AccountNames,
1623 PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer,
1624 PLSAPR_TRANSLATED_SID_EX2 SidsBuffer,
1625 PULONG Mapped)
1626{
1627 SAMPR_HANDLE ServerHandle = NULL;
1628 SAMPR_HANDLE DomainHandle = NULL;
1629 SAMPR_ULONG_ARRAY RelativeIds = {0, NULL};
1630 SAMPR_ULONG_ARRAY Use = {0, NULL};
1631 ULONG DomainIndex;
1632 ULONG i;
1633 NTSTATUS Status = STATUS_SUCCESS;
1634
1635 Status = SamrConnect(NULL,
1636 &ServerHandle,
1637 SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN);
1638 if (!NT_SUCCESS(Status))
1639 {
1640 TRACE("SamrConnect failed (Status %08lx)\n", Status);
1641 goto done;
1642 }
1643
1644 Status = SamrOpenDomain(ServerHandle,
1645 DOMAIN_LOOKUP,
1646 BuiltinDomainSid,
1647 &DomainHandle);
1648 if (!NT_SUCCESS(Status))
1649 {
1650 TRACE("SamOpenDomain failed (Status %08lx)\n", Status);
1651 goto done;
1652 }
1653
1654 for (i = 0; i < Count; i++)
1655 {
1656 /* Ignore names which were already mapped */
1657 if (SidsBuffer[i].Use != SidTypeUnknown)
1658 continue;
1659
1660 /* Ignore isolated account names */
1661 if (DomainNames[i].Length == 0)
1662 continue;
1663
1664 if (!RtlEqualUnicodeString((PUNICODE_STRING)&DomainNames[i], &BuiltinDomainName, TRUE))
1665 continue;
1666
1667 TRACE("Mapping name: %wZ\\%wZ\n", &DomainNames[i], &AccountNames[i]);
1668
1669 Status = SamrLookupNamesInDomain(DomainHandle,
1670 1,
1671 &AccountNames[i],
1672 &RelativeIds,
1673 &Use);
1674 if (NT_SUCCESS(Status))
1675 {
1676 SidsBuffer[i].Use = Use.Element[0];
1677 SidsBuffer[i].Sid = CreateSidFromSidAndRid(BuiltinDomainSid,
1678 RelativeIds.Element[0]);
1679 if (SidsBuffer[i].Sid == NULL)
1680 {
1681 Status = STATUS_INSUFFICIENT_RESOURCES;
1682 goto done;
1683 }
1684
1685 SidsBuffer[i].DomainIndex = -1;
1686 SidsBuffer[i].Flags = 0;
1687
1688 Status = LsapAddDomainToDomainsList(DomainsBuffer,
1689 &BuiltinDomainName,
1690 BuiltinDomainSid,
1691 &DomainIndex);
1692 if (!NT_SUCCESS(Status))
1693 goto done;
1694
1695 SidsBuffer[i].DomainIndex = DomainIndex;
1696
1697 (*Mapped)++;
1698 }
1699
1700 SamIFree_SAMPR_ULONG_ARRAY(&RelativeIds);
1701 SamIFree_SAMPR_ULONG_ARRAY(&Use);
1702 }
1703
1704done:
1705 if (DomainHandle != NULL)
1706 SamrCloseHandle(&DomainHandle);
1707
1708 if (ServerHandle != NULL)
1709 SamrCloseHandle(&ServerHandle);
1710
1711 return Status;
1712}
1713
1714
1715static
1716NTSTATUS
1717LsapLookupAccountNames(DWORD Count,
1718 PRPC_UNICODE_STRING DomainNames,
1719 PRPC_UNICODE_STRING AccountNames,
1720 PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer,
1721 PLSAPR_TRANSLATED_SID_EX2 SidsBuffer,
1722 PULONG Mapped)
1723{
1724 SAMPR_HANDLE ServerHandle = NULL;
1725 SAMPR_HANDLE DomainHandle = NULL;
1726 SAMPR_ULONG_ARRAY RelativeIds = {0, NULL};
1727 SAMPR_ULONG_ARRAY Use = {0, NULL};
1728 ULONG DomainIndex;
1729 ULONG i;
1730 NTSTATUS Status = STATUS_SUCCESS;
1731
1732 Status = SamrConnect(NULL,
1733 &ServerHandle,
1734 SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN);
1735 if (!NT_SUCCESS(Status))
1736 {
1737 TRACE("SamrConnect failed (Status %08lx)\n", Status);
1738 goto done;
1739 }
1740
1741 Status = SamrOpenDomain(ServerHandle,
1742 DOMAIN_LOOKUP,
1743 AccountDomainSid,
1744 &DomainHandle);
1745 if (!NT_SUCCESS(Status))
1746 {
1747 TRACE("SamOpenDomain failed (Status %08lx)\n", Status);
1748 goto done;
1749 }
1750
1751 for (i = 0; i < Count; i++)
1752 {
1753 /* Ignore names which were already mapped */
1754 if (SidsBuffer[i].Use != SidTypeUnknown)
1755 continue;
1756
1757 /* Ignore isolated account names */
1758 if (DomainNames[i].Length == 0)
1759 continue;
1760
1761 if (!RtlEqualUnicodeString((PUNICODE_STRING)&DomainNames[i], &AccountDomainName, TRUE))
1762 continue;
1763
1764 TRACE("Mapping name: %wZ\\%wZ\n", &DomainNames[i], &AccountNames[i]);
1765
1766 Status = SamrLookupNamesInDomain(DomainHandle,
1767 1,
1768 &AccountNames[i],
1769 &RelativeIds,
1770 &Use);
1771 if (NT_SUCCESS(Status))
1772 {
1773 SidsBuffer[i].Use = Use.Element[0];
1774 SidsBuffer[i].Sid = CreateSidFromSidAndRid(AccountDomainSid,
1775 RelativeIds.Element[0]);
1776 if (SidsBuffer[i].Sid == NULL)
1777 {
1778 Status = STATUS_INSUFFICIENT_RESOURCES;
1779 goto done;
1780 }
1781
1782 SidsBuffer[i].DomainIndex = -1;
1783 SidsBuffer[i].Flags = 0;
1784
1785 Status = LsapAddDomainToDomainsList(DomainsBuffer,
1786 &AccountDomainName,
1787 AccountDomainSid,
1788 &DomainIndex);
1789 if (!NT_SUCCESS(Status))
1790 goto done;
1791
1792 SidsBuffer[i].DomainIndex = DomainIndex;
1793
1794 (*Mapped)++;
1795 }
1796
1797 SamIFree_SAMPR_ULONG_ARRAY(&RelativeIds);
1798 SamIFree_SAMPR_ULONG_ARRAY(&Use);
1799 }
1800
1801done:
1802 if (DomainHandle != NULL)
1803 SamrCloseHandle(&DomainHandle);
1804
1805 if (ServerHandle != NULL)
1806 SamrCloseHandle(&ServerHandle);
1807
1808 return Status;
1809}
1810
1811
1812NTSTATUS
1813LsapLookupNames(DWORD Count,
1814 PRPC_UNICODE_STRING Names,
1815 PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
1816 PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids,
1817 LSAP_LOOKUP_LEVEL LookupLevel,
1818 DWORD *MappedCount,
1819 DWORD LookupOptions,
1820 DWORD ClientRevision)
1821{
1822 PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer = NULL;
1823 PLSAPR_TRANSLATED_SID_EX2 SidsBuffer = NULL;
1824 PRPC_UNICODE_STRING DomainNames = NULL;
1825 PRPC_UNICODE_STRING AccountNames = NULL;
1826 ULONG SidsBufferLength;
1827 ULONG i;
1828 ULONG Mapped = 0;
1829 NTSTATUS Status = STATUS_SUCCESS;
1830
1831//TRACE("()\n");
1832
1833 TranslatedSids->Entries = 0;
1834 TranslatedSids->Sids = NULL;
1835 *ReferencedDomains = NULL;
1836
1837 SidsBufferLength = Count * sizeof(LSAPR_TRANSLATED_SID_EX2);
1838 SidsBuffer = MIDL_user_allocate(SidsBufferLength);
1839 if (SidsBuffer == NULL)
1840 {
1841//TRACE("\n");
1842 Status = STATUS_INSUFFICIENT_RESOURCES;
1843 goto done;
1844 }
1845
1846 DomainsBuffer = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
1847 if (DomainsBuffer == NULL)
1848 {
1849//TRACE("\n");
1850 Status = STATUS_INSUFFICIENT_RESOURCES;
1851 goto done;
1852 }
1853
1854 DomainsBuffer->Domains = MIDL_user_allocate(Count * sizeof(LSA_TRUST_INFORMATION));
1855 if (DomainsBuffer->Domains == NULL)
1856 {
1857//TRACE("\n");
1858 Status = STATUS_INSUFFICIENT_RESOURCES;
1859 goto done;
1860 }
1861 DomainsBuffer->Entries = 0;
1862 DomainsBuffer->MaxEntries = Count;
1863
1864 for (i = 0; i < Count; i++)
1865 {
1866 SidsBuffer[i].Use = SidTypeUnknown;
1867 SidsBuffer[i].Sid = NULL;
1868 SidsBuffer[i].DomainIndex = -1;
1869 SidsBuffer[i].Flags = 0;
1870 }
1871
1872 Status = LsapSplitNames(Count,
1873 Names,
1874 &DomainNames,
1875 &AccountNames);
1876 if (!NT_SUCCESS(Status))
1877 {
1878 TRACE("LsapSplitNames failed! (Status %lx)\n", Status);
1879 goto done;
1880 }
1881
1882
1883 Status = LsapLookupIsolatedNames(Count,
1884 DomainNames,
1885 AccountNames,
1886 DomainsBuffer,
1887 SidsBuffer,
1888 &Mapped);
1889 if (!NT_SUCCESS(Status) &&
1890 Status != STATUS_NONE_MAPPED &&
1891 Status != STATUS_SOME_NOT_MAPPED)
1892 {
1893 TRACE("LsapLookupIsolatedNames failed! (Status %lx)\n", Status);
1894 goto done;
1895 }
1896
1897 if (Mapped == Count)
1898 goto done;
1899
1900
1901 Status = LsapLookupIsolatedBuiltinNames(Count,
1902 DomainNames,
1903 AccountNames,
1904 DomainsBuffer,
1905 SidsBuffer,
1906 &Mapped);
1907 if (!NT_SUCCESS(Status) &&
1908 Status != STATUS_NONE_MAPPED &&
1909 Status != STATUS_SOME_NOT_MAPPED)
1910 {
1911 TRACE("LsapLookupIsolatedBuiltinNames failed! (Status %lx)\n", Status);
1912 goto done;
1913 }
1914
1915 if (Mapped == Count)
1916 goto done;
1917
1918
1919 Status = LsapLookupIsolatedAccountNames(Count,
1920 DomainNames,
1921 AccountNames,
1922 DomainsBuffer,
1923 SidsBuffer,
1924 &Mapped);
1925 if (!NT_SUCCESS(Status) &&
1926 Status != STATUS_NONE_MAPPED &&
1927 Status != STATUS_SOME_NOT_MAPPED)
1928 {
1929 TRACE("LsapLookupIsolatedAccountNames failed! (Status %lx)\n", Status);
1930 goto done;
1931 }
1932
1933 if (Mapped == Count)
1934 goto done;
1935
1936 Status = LsapLookupFullyQualifiedWellKnownNames(Count,
1937 DomainNames,
1938 AccountNames,
1939 DomainsBuffer,
1940 SidsBuffer,
1941 &Mapped);
1942 if (!NT_SUCCESS(Status) &&
1943 Status != STATUS_NONE_MAPPED &&
1944 Status != STATUS_SOME_NOT_MAPPED)
1945 {
1946 TRACE("LsapLookupFullyQualifiedWellKnownNames failed! (Status %lx)\n", Status);
1947 goto done;
1948 }
1949
1950 if (Mapped == Count)
1951 goto done;
1952
1953 Status = LsapLookupBuiltinNames(Count,
1954 DomainNames,
1955 AccountNames,
1956 DomainsBuffer,
1957 SidsBuffer,
1958 &Mapped);
1959 if (!NT_SUCCESS(Status) &&
1960 Status != STATUS_NONE_MAPPED &&
1961 Status != STATUS_SOME_NOT_MAPPED)
1962 {
1963 TRACE("LsapLookupBuiltinNames failed! (Status %lx)\n", Status);
1964 goto done;
1965 }
1966
1967 if (Mapped == Count)
1968 goto done;
1969
1970
1971 Status = LsapLookupAccountNames(Count,
1972 DomainNames,
1973 AccountNames,
1974 DomainsBuffer,
1975 SidsBuffer,
1976 &Mapped);
1977 if (!NT_SUCCESS(Status) &&
1978 Status != STATUS_NONE_MAPPED &&
1979 Status != STATUS_SOME_NOT_MAPPED)
1980 {
1981 TRACE("LsapLookupAccountNames failed! (Status %lx)\n", Status);
1982 goto done;
1983 }
1984
1985 if (Mapped == Count)
1986 goto done;
1987
1988done:
1989// TRACE("done: Status %lx\n", Status);
1990
1991 if (DomainNames != NULL)
1992 {
1993//TRACE("Free DomainNames\n");
1994 for (i = 0; i < Count; i++)
1995 {
1996 if (DomainNames[i].Buffer != NULL)
1997 MIDL_user_free(DomainNames[i].Buffer);
1998 }
1999
2000 MIDL_user_free(DomainNames);
2001 }
2002
2003 if (AccountNames != NULL)
2004 {
2005//TRACE("Free AccountNames\n");
2006 for (i = 0; i < Count; i++)
2007 {
2008//TRACE("i: %lu\n", i);
2009 if (AccountNames[i].Buffer != NULL)
2010 {
2011 MIDL_user_free(AccountNames[i].Buffer);
2012 }
2013 }
2014
2015 MIDL_user_free(AccountNames);
2016 }
2017
2018 if (!NT_SUCCESS(Status))
2019 {
2020//TRACE("Failure!\n");
2021
2022//TRACE("Free DomainsBuffer\n");
2023 if (DomainsBuffer != NULL)
2024 {
2025 if (DomainsBuffer->Domains != NULL)
2026 MIDL_user_free(DomainsBuffer->Domains);
2027
2028 MIDL_user_free(DomainsBuffer);
2029 }
2030
2031//TRACE("Free SidsBuffer\n");
2032 if (SidsBuffer != NULL)
2033 MIDL_user_free(SidsBuffer);
2034 }
2035 else
2036 {
2037//TRACE("Success!\n");
2038
2039 *ReferencedDomains = DomainsBuffer;
2040 TranslatedSids->Entries = Count;
2041 TranslatedSids->Sids = SidsBuffer;
2042 *MappedCount = Mapped;
2043
2044 if (Mapped == 0)
2045 Status = STATUS_NONE_MAPPED;
2046 else if (Mapped < Count)
2047 Status = STATUS_SOME_NOT_MAPPED;
2048 }
2049
2050// TRACE("done: Status %lx\n", Status);
2051
2052 return Status;
2053}
2054
2055
2056static NTSTATUS
2057LsapLookupWellKnownSids(PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
2058 PLSAPR_TRANSLATED_NAME_EX NamesBuffer,
2059 PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer,
2060 PULONG Mapped)
2061{
2062 PWELL_KNOWN_SID ptr, ptr2;
2063 LPWSTR SidString = NULL;
2064 ULONG DomainIndex;
2065 ULONG i;
2066 NTSTATUS Status = STATUS_SUCCESS;
2067
2068 for (i = 0; i < SidEnumBuffer->Entries; i++)
2069 {
2070 /* Ignore SIDs which are already mapped */
2071 if (NamesBuffer[i].Use != SidTypeUnknown)
2072 continue;
2073
2074 ConvertSidToStringSidW(SidEnumBuffer->SidInfo[i].Sid, &SidString);
2075 TRACE("Mapping SID: %S\n", SidString);
2076 LocalFree(SidString);
2077 SidString = NULL;
2078
2079 ptr = LsapLookupWellKnownSid(SidEnumBuffer->SidInfo[i].Sid);
2080 if (ptr != NULL)
2081 {
2082 NamesBuffer[i].Use = ptr->Use;
2083 NamesBuffer[i].Flags = 0;
2084
2085 NamesBuffer[i].Name.Length = ptr->AccountName.Length;
2086 NamesBuffer[i].Name.MaximumLength = ptr->AccountName.MaximumLength;
2087 NamesBuffer[i].Name.Buffer = MIDL_user_allocate(ptr->AccountName.MaximumLength);
2088 if (NamesBuffer[i].Name.Buffer == NULL)
2089 {
2090 Status = STATUS_INSUFFICIENT_RESOURCES;
2091 goto done;
2092 }
2093
2094 RtlCopyMemory(NamesBuffer[i].Name.Buffer, ptr->AccountName.Buffer, ptr->AccountName.MaximumLength);
2095
2096 if (ptr->DomainName.Length == 0)
2097 {
2098 Status = LsapAddAuthorityToDomainsList(DomainsBuffer,
2099 SidEnumBuffer->SidInfo[i].Sid,
2100 &DomainIndex);
2101 if (!NT_SUCCESS(Status))
2102 goto done;
2103
2104 NamesBuffer[i].DomainIndex = DomainIndex;
2105 }
2106 else
2107 {
2108 ptr2= LsapLookupIsolatedWellKnownName(&ptr->DomainName);
2109 if (ptr2 != NULL)
2110 {
2111 Status = LsapAddDomainToDomainsList(DomainsBuffer,
2112 &ptr2->AccountName,
2113 ptr2->Sid,
2114 &DomainIndex);
2115 if (!NT_SUCCESS(Status))
2116 goto done;
2117
2118 NamesBuffer[i].DomainIndex = DomainIndex;
2119 }
2120 }
2121
2122 TRACE("Mapped to: %wZ\n", &NamesBuffer[i].Name);
2123
2124 (*Mapped)++;
2125 }
2126 }
2127
2128done:
2129 return Status;
2130}
2131
2132
2133static NTSTATUS
2134LsapLookupBuiltinDomainSids(PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
2135 PLSAPR_TRANSLATED_NAME_EX NamesBuffer,
2136 PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer,
2137 PULONG Mapped)
2138{
2139 SAMPR_HANDLE ServerHandle = NULL;
2140 SAMPR_HANDLE DomainHandle = NULL;
2141 SAMPR_RETURNED_USTRING_ARRAY Names = {0, NULL};
2142 SAMPR_ULONG_ARRAY Use = {0, NULL};
2143 LPWSTR SidString = NULL;
2144 ULONG DomainIndex;
2145 ULONG RelativeIds[1];
2146 ULONG i;
2147 NTSTATUS Status = STATUS_SUCCESS;
2148
2149 Status = SamrConnect(NULL,
2150 &ServerHandle,
2151 SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN);
2152 if (!NT_SUCCESS(Status))
2153 {
2154 TRACE("SamrConnect failed (Status %08lx)\n", Status);
2155 goto done;
2156 }
2157
2158 Status = SamrOpenDomain(ServerHandle,
2159 DOMAIN_LOOKUP,
2160 BuiltinDomainSid,
2161 &DomainHandle);
2162 if (!NT_SUCCESS(Status))
2163 {
2164 TRACE("SamOpenDomain failed (Status %08lx)\n", Status);
2165 goto done;
2166 }
2167
2168 for (i = 0; i < SidEnumBuffer->Entries; i++)
2169 {
2170 /* Ignore SIDs which are already mapped */
2171 if (NamesBuffer[i].Use != SidTypeUnknown)
2172 continue;
2173
2174 ConvertSidToStringSidW(SidEnumBuffer->SidInfo[i].Sid, &SidString);
2175 TRACE("Mapping SID: %S\n", SidString);
2176 LocalFree(SidString);
2177 SidString = NULL;
2178
2179 if (RtlEqualSid(BuiltinDomainSid, SidEnumBuffer->SidInfo[i].Sid))
2180 {
2181 TRACE("Found builtin domain!\n");
2182
2183 NamesBuffer[i].Use = SidTypeDomain;
2184 NamesBuffer[i].Flags = 0;
2185
2186 NamesBuffer[i].Name.Length = BuiltinDomainName.Length;
2187 NamesBuffer[i].Name.MaximumLength = BuiltinDomainName.MaximumLength;
2188 NamesBuffer[i].Name.Buffer = MIDL_user_allocate(BuiltinDomainName.MaximumLength);
2189 if (NamesBuffer[i].Name.Buffer == NULL)
2190 {
2191 Status = STATUS_INSUFFICIENT_RESOURCES;
2192 goto done;
2193 }
2194
2195 RtlCopyMemory(NamesBuffer[i].Name.Buffer, BuiltinDomainName.Buffer, BuiltinDomainName.MaximumLength);
2196
2197 Status = LsapAddDomainToDomainsList(DomainsBuffer,
2198 &BuiltinDomainName,
2199 BuiltinDomainSid,
2200 &DomainIndex);
2201 if (!NT_SUCCESS(Status))
2202 goto done;
2203
2204 NamesBuffer[i].DomainIndex = DomainIndex;
2205
2206 TRACE("Mapped to: %wZ\n", &NamesBuffer[i].Name);
2207
2208 (*Mapped)++;
2209 }
2210 else if (LsapIsPrefixSid(BuiltinDomainSid, SidEnumBuffer->SidInfo[i].Sid))
2211 {
2212 TRACE("Found builtin domain account!\n");
2213
2214 RelativeIds[0] = LsapGetRelativeIdFromSid(SidEnumBuffer->SidInfo[i].Sid);
2215
2216 Status = SamrLookupIdsInDomain(DomainHandle,
2217 1,
2218 RelativeIds,
2219 &Names,
2220 &Use);
2221 if (NT_SUCCESS(Status))
2222 {
2223 NamesBuffer[i].Use = Use.Element[0];
2224 NamesBuffer[i].Flags = 0;
2225
2226 NamesBuffer[i].Name.Length = Names.Element[0].Length;
2227 NamesBuffer[i].Name.MaximumLength = Names.Element[0].MaximumLength;
2228 NamesBuffer[i].Name.Buffer = MIDL_user_allocate(Names.Element[0].MaximumLength);
2229 if (NamesBuffer[i].Name.Buffer == NULL)
2230 {
2231 SamIFree_SAMPR_RETURNED_USTRING_ARRAY(&Names);
2232 SamIFree_SAMPR_ULONG_ARRAY(&Use);
2233
2234 Status = STATUS_INSUFFICIENT_RESOURCES;
2235 goto done;
2236 }
2237
2238 RtlCopyMemory(NamesBuffer[i].Name.Buffer,
2239 Names.Element[0].Buffer,
2240 Names.Element[0].MaximumLength);
2241
2242 SamIFree_SAMPR_RETURNED_USTRING_ARRAY(&Names);
2243 SamIFree_SAMPR_ULONG_ARRAY(&Use);
2244
2245 Status = LsapAddDomainToDomainsList(DomainsBuffer,
2246 &BuiltinDomainName,
2247 BuiltinDomainSid,
2248 &DomainIndex);
2249 if (!NT_SUCCESS(Status))
2250 goto done;
2251
2252 NamesBuffer[i].DomainIndex = DomainIndex;
2253
2254 TRACE("Mapped to: %wZ\n", &NamesBuffer[i].Name);
2255
2256 (*Mapped)++;
2257 }
2258 }
2259 }
2260
2261done:
2262 if (DomainHandle != NULL)
2263 SamrCloseHandle(&DomainHandle);
2264
2265 if (ServerHandle != NULL)
2266 SamrCloseHandle(&ServerHandle);
2267
2268 return Status;
2269}
2270
2271
2272static NTSTATUS
2273LsapLookupAccountDomainSids(PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
2274 PLSAPR_TRANSLATED_NAME_EX NamesBuffer,
2275 PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer,
2276 PULONG Mapped)
2277{
2278 SAMPR_HANDLE ServerHandle = NULL;
2279 SAMPR_HANDLE DomainHandle = NULL;
2280 SAMPR_RETURNED_USTRING_ARRAY Names = {0, NULL};
2281 SAMPR_ULONG_ARRAY Use = {0, NULL};
2282 LPWSTR SidString = NULL;
2283 ULONG DomainIndex;
2284 ULONG RelativeIds[1];
2285 ULONG i;
2286 NTSTATUS Status = STATUS_SUCCESS;
2287
2288 Status = SamrConnect(NULL,
2289 &ServerHandle,
2290 SAM_SERVER_CONNECT | SAM_SERVER_LOOKUP_DOMAIN);
2291 if (!NT_SUCCESS(Status))
2292 {
2293 TRACE("SamrConnect failed (Status %08lx)\n", Status);
2294 goto done;
2295 }
2296
2297 Status = SamrOpenDomain(ServerHandle,
2298 DOMAIN_LOOKUP,
2299 AccountDomainSid,
2300 &DomainHandle);
2301 if (!NT_SUCCESS(Status))
2302 {
2303 TRACE("SamOpenDomain failed (Status %08lx)\n", Status);
2304 goto done;
2305 }
2306
2307 for (i = 0; i < SidEnumBuffer->Entries; i++)
2308 {
2309 /* Ignore SIDs which are already mapped */
2310 if (NamesBuffer[i].Use != SidTypeUnknown)
2311 continue;
2312
2313 ConvertSidToStringSidW(SidEnumBuffer->SidInfo[i].Sid, &SidString);
2314 TRACE("Mapping SID: %S\n", SidString);
2315 LocalFree(SidString);
2316 SidString = NULL;
2317
2318 if (RtlEqualSid(AccountDomainSid, SidEnumBuffer->SidInfo[i].Sid))
2319 {
2320 TRACE("Found account domain!\n");
2321
2322 NamesBuffer[i].Use = SidTypeDomain;
2323 NamesBuffer[i].Flags = 0;
2324
2325 NamesBuffer[i].Name.Length = AccountDomainName.Length;
2326 NamesBuffer[i].Name.MaximumLength = AccountDomainName.MaximumLength;
2327 NamesBuffer[i].Name.Buffer = MIDL_user_allocate(AccountDomainName.MaximumLength);
2328 if (NamesBuffer[i].Name.Buffer == NULL)
2329 {
2330 Status = STATUS_INSUFFICIENT_RESOURCES;
2331 goto done;
2332 }
2333
2334 RtlCopyMemory(NamesBuffer[i].Name.Buffer, AccountDomainName.Buffer, AccountDomainName.MaximumLength);
2335
2336 Status = LsapAddDomainToDomainsList(DomainsBuffer,
2337 &AccountDomainName,
2338 AccountDomainSid,
2339 &DomainIndex);
2340 if (!NT_SUCCESS(Status))
2341 goto done;
2342
2343 NamesBuffer[i].DomainIndex = DomainIndex;
2344
2345 TRACE("Mapped to: %wZ\n", &NamesBuffer[i].Name);
2346
2347 (*Mapped)++;
2348 }
2349 else if (LsapIsPrefixSid(AccountDomainSid, SidEnumBuffer->SidInfo[i].Sid))
2350 {
2351 TRACE("Found account domain account!\n");
2352
2353 RelativeIds[0] = LsapGetRelativeIdFromSid(SidEnumBuffer->SidInfo[i].Sid);
2354
2355 Status = SamrLookupIdsInDomain(DomainHandle,
2356 1,
2357 RelativeIds,
2358 &Names,
2359 &Use);
2360 if (NT_SUCCESS(Status))
2361 {
2362 NamesBuffer[i].Use = Use.Element[0];
2363 NamesBuffer[i].Flags = 0;
2364
2365 NamesBuffer[i].Name.Length = Names.Element[0].Length;
2366 NamesBuffer[i].Name.MaximumLength = Names.Element[0].MaximumLength;
2367 NamesBuffer[i].Name.Buffer = MIDL_user_allocate(Names.Element[0].MaximumLength);
2368 if (NamesBuffer[i].Name.Buffer == NULL)
2369 {
2370 SamIFree_SAMPR_RETURNED_USTRING_ARRAY(&Names);
2371 SamIFree_SAMPR_ULONG_ARRAY(&Use);
2372
2373 Status = STATUS_INSUFFICIENT_RESOURCES;
2374 goto done;
2375 }
2376
2377 RtlCopyMemory(NamesBuffer[i].Name.Buffer,
2378 Names.Element[0].Buffer,
2379 Names.Element[0].MaximumLength);
2380
2381 SamIFree_SAMPR_RETURNED_USTRING_ARRAY(&Names);
2382 SamIFree_SAMPR_ULONG_ARRAY(&Use);
2383
2384 Status = LsapAddDomainToDomainsList(DomainsBuffer,
2385 &AccountDomainName,
2386 AccountDomainSid,
2387 &DomainIndex);
2388 if (!NT_SUCCESS(Status))
2389 goto done;
2390
2391 NamesBuffer[i].DomainIndex = DomainIndex;
2392
2393 TRACE("Mapped to: %wZ\n", &NamesBuffer[i].Name);
2394
2395 (*Mapped)++;
2396 }
2397 }
2398 }
2399
2400done:
2401 if (DomainHandle != NULL)
2402 SamrCloseHandle(&DomainHandle);
2403
2404 if (ServerHandle != NULL)
2405 SamrCloseHandle(&ServerHandle);
2406
2407 return Status;
2408}
2409
2410
2411NTSTATUS
2412LsapLookupSids(PLSAPR_SID_ENUM_BUFFER SidEnumBuffer,
2413 PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains,
2414 PLSAPR_TRANSLATED_NAMES_EX TranslatedNames,
2415 LSAP_LOOKUP_LEVEL LookupLevel,
2416 DWORD *MappedCount,
2417 DWORD LookupOptions,
2418 DWORD ClientRevision)
2419{
2420 PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer = NULL;
2421 PLSAPR_TRANSLATED_NAME_EX NamesBuffer = NULL;
2422 ULONG NamesBufferLength;
2423 ULONG i;
2424 ULONG Mapped = 0;
2425 NTSTATUS Status = STATUS_SUCCESS;
2426
2427 NamesBufferLength = SidEnumBuffer->Entries * sizeof(LSAPR_TRANSLATED_NAME_EX);
2428 NamesBuffer = MIDL_user_allocate(NamesBufferLength);
2429 if (NamesBuffer == NULL)
2430 {
2431 Status = STATUS_INSUFFICIENT_RESOURCES;
2432 goto done;
2433 }
2434
2435 DomainsBuffer = MIDL_user_allocate(sizeof(LSAPR_REFERENCED_DOMAIN_LIST));
2436 if (DomainsBuffer == NULL)
2437 {
2438 Status = STATUS_INSUFFICIENT_RESOURCES;
2439 goto done;
2440 }
2441
2442 DomainsBuffer->Domains = MIDL_user_allocate(SidEnumBuffer->Entries * sizeof(LSA_TRUST_INFORMATION));
2443 if (DomainsBuffer->Domains == NULL)
2444 {
2445 Status = STATUS_INSUFFICIENT_RESOURCES;
2446 goto done;
2447 }
2448
2449 DomainsBuffer->Entries = 0;
2450 DomainsBuffer->MaxEntries = SidEnumBuffer->Entries;
2451
2452 /* Initialize all name entries */
2453 for (i = 0; i < SidEnumBuffer->Entries; i++)
2454 {
2455 NamesBuffer[i].Use = SidTypeUnknown;
2456 NamesBuffer[i].Name.Length = 0;
2457 NamesBuffer[i].Name.MaximumLength = 0;
2458 NamesBuffer[i].Name.Buffer = NULL;
2459 NamesBuffer[i].DomainIndex = -1;
2460 NamesBuffer[i].Flags = 0;
2461 }
2462
2463 /* Look-up well-known SIDs */
2464 Status = LsapLookupWellKnownSids(SidEnumBuffer,
2465 NamesBuffer,
2466 DomainsBuffer,
2467 &Mapped);
2468 if (!NT_SUCCESS(Status) &&
2469 Status != STATUS_NONE_MAPPED &&
2470 Status != STATUS_SOME_NOT_MAPPED)
2471 goto done;
2472
2473 if (Mapped == SidEnumBuffer->Entries)
2474 goto done;
2475
2476 /* Look-up builtin domain SIDs */
2477 Status = LsapLookupBuiltinDomainSids(SidEnumBuffer,
2478 NamesBuffer,
2479 DomainsBuffer,
2480 &Mapped);
2481 if (!NT_SUCCESS(Status) &&
2482 Status != STATUS_NONE_MAPPED &&
2483 Status != STATUS_SOME_NOT_MAPPED)
2484 goto done;
2485
2486 if (Mapped == SidEnumBuffer->Entries)
2487 goto done;
2488
2489 /* Look-up account domain SIDs */
2490 Status = LsapLookupAccountDomainSids(SidEnumBuffer,
2491 NamesBuffer,
2492 DomainsBuffer,
2493 &Mapped);
2494 if (!NT_SUCCESS(Status) &&
2495 Status != STATUS_NONE_MAPPED &&
2496 Status != STATUS_SOME_NOT_MAPPED)
2497 goto done;
2498
2499 if (Mapped == SidEnumBuffer->Entries)
2500 goto done;
2501
2502done:
2503 TRACE("done Status: %lx Mapped: %lu\n", Status, Mapped);
2504
2505 if (!NT_SUCCESS(Status))
2506 {
2507 if (DomainsBuffer != NULL)
2508 {
2509 if (DomainsBuffer->Domains != NULL)
2510 MIDL_user_free(DomainsBuffer->Domains);
2511
2512 MIDL_user_free(DomainsBuffer);
2513 }
2514
2515 if (NamesBuffer != NULL)
2516 MIDL_user_free(NamesBuffer);
2517 }
2518 else
2519 {
2520 *ReferencedDomains = DomainsBuffer;
2521 TranslatedNames->Entries = SidEnumBuffer->Entries;
2522 TranslatedNames->Names = NamesBuffer;
2523 *MappedCount = Mapped;
2524
2525 if (Mapped == 0)
2526 Status = STATUS_NONE_MAPPED;
2527 else if (Mapped < SidEnumBuffer->Entries)
2528 Status = STATUS_SOME_NOT_MAPPED;
2529 }
2530
2531 return Status;
2532}
2533
2534/* EOF */
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
Names
PWSTR Names[]
Definition: RtlGenerate8dot3Name.c:34
PSAMPR_SERVER_NAME
wchar_t * PSAMPR_SERVER_NAME
Definition: authpackage.c:112
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
BuiltinDomainSid
PSID BuiltinDomainSid
Definition: globals.c:16
NtAuthority
static SID_IDENTIFIER_AUTHORITY NtAuthority
Definition: security.c:40
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
hInstance
HINSTANCE hInstance
Definition: charmap.c:19
Buffer
Definition: bufpool.h:45
wcscpy
wcscpy
Definition: corecrt_wstring.h:120
Name
LPWSTR Name
Definition: desk.c:124
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
ARRAYSIZE
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
ConvertSidToStringSidW
BOOL WINAPI ConvertSidToStringSidW(PSID Sid, LPWSTR *StringSid)
Definition: security.c:3583
wcschr
#define wcschr
Definition: compat.h:17
HEAP_ZERO_MEMORY
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
GetModuleHandleW
HMODULE WINAPI GetModuleHandleW(LPCWSTR lpModuleName)
Definition: loader.c:838
CreatorSidAuthority
SID_IDENTIFIER_AUTHORITY CreatorSidAuthority
Definition: database.c:20
BuiltinDomainName
UNICODE_STRING BuiltinDomainName
Definition: database.c:25
AccountDomainName
UNICODE_STRING AccountDomainName
Definition: database.c:26
NullSidAuthority
SID_IDENTIFIER_AUTHORITY NullSidAuthority
Definition: database.c:17
LocalSidAuthority
SID_IDENTIFIER_AUTHORITY LocalSidAuthority
Definition: database.c:19
WorldSidAuthority
SID_IDENTIFIER_AUTHORITY WorldSidAuthority
Definition: database.c:18
AccountDomainSid
PSID AccountDomainSid
Definition: database.c:24
PSAMPR_RETURNED_USTRING_ARRAY
struct _SAMPR_RETURNED_USTRING_ARRAY * PSAMPR_RETURNED_USTRING_ARRAY
LsapLookupWellKnownSid
PWELL_KNOWN_SID LsapLookupWellKnownSid(PSID Sid)
Definition: lookup.c:698
SAMPR_RETURNED_USTRING_ARRAY
struct _SAMPR_RETURNED_USTRING_ARRAY SAMPR_RETURNED_USTRING_ARRAY
LsapAddAuthorityToDomainsList
static NTSTATUS LsapAddAuthorityToDomainsList(PLSAPR_REFERENCED_DOMAIN_LIST ReferencedDomains, PSID Sid, PULONG Index)
Definition: lookup.c:953
LsapLookupBuiltinNames
static NTSTATUS LsapLookupBuiltinNames(DWORD Count, PRPC_UNICODE_STRING DomainNames, PRPC_UNICODE_STRING AccountNames, PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer, PLSAPR_TRANSLATED_SID_EX2 SidsBuffer, PULONG Mapped)
Definition: lookup.c:1620
LsapLookupWellKnownSids
static NTSTATUS LsapLookupWellKnownSids(PLSAPR_SID_ENUM_BUFFER SidEnumBuffer, PLSAPR_TRANSLATED_NAME_EX NamesBuffer, PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer, PULONG Mapped)
Definition: lookup.c:2057
LsapServiceSid
PSID LsapServiceSid
Definition: lookup.c:82
CreateDomainSidFromAccountSid
static PSID CreateDomainSidFromAccountSid(PSID AccountSid)
Definition: lookup.c:1088
WellKnownSidListHead
LIST_ENTRY WellKnownSidListHead
Definition: lookup.c:77
LsapAdministratorsSid
PSID LsapAdministratorsSid
Definition: lookup.c:84
SamIFree_SAMPR_ULONG_ARRAY
VOID NTAPI SamIFree_SAMPR_ULONG_ARRAY(PSAMPR_ULONG_ARRAY Ptr)
Definition: samsrv.c:524
LsapGetRelativeIdFromSid
ULONG LsapGetRelativeIdFromSid(PSID Sid_)
Definition: lookup.c:1038
LsapNetworkSid
PSID LsapNetworkSid
Definition: lookup.c:79
LsapLookupFullyQualifiedWellKnownName
PWELL_KNOWN_SID LsapLookupFullyQualifiedWellKnownName(PUNICODE_STRING AccountName, PUNICODE_STRING DomainName)
Definition: lookup.c:746
LsapLookupFullyQualifiedWellKnownNames
static NTSTATUS LsapLookupFullyQualifiedWellKnownNames(DWORD Count, PRPC_UNICODE_STRING DomainNames, PRPC_UNICODE_STRING AccountNames, PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer, PLSAPR_TRANSLATED_SID_EX2 SidsBuffer, PULONG Mapped)
Definition: lookup.c:1512
LsapCopySid
static PSID LsapCopySid(PSID SrcSid)
Definition: lookup.c:1122
LsapLookupIsolatedWellKnownName
PWELL_KNOWN_SID LsapLookupIsolatedWellKnownName(PUNICODE_STRING AccountName)
Definition: lookup.c:722
LsapLookupBuiltinDomainSids
static NTSTATUS LsapLookupBuiltinDomainSids(PLSAPR_SID_ENUM_BUFFER SidEnumBuffer, PLSAPR_TRANSLATED_NAME_EX NamesBuffer, PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer, PULONG Mapped)
Definition: lookup.c:2134
LsapLookupNames
NTSTATUS LsapLookupNames(DWORD Count, PRPC_UNICODE_STRING Names, PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains, PLSAPR_TRANSLATED_SIDS_EX2 TranslatedSids, LSAP_LOOKUP_LEVEL LookupLevel, DWORD *MappedCount, DWORD LookupOptions, DWORD ClientRevision)
Definition: lookup.c:1813
LsapIsPrefixSid
static BOOLEAN LsapIsPrefixSid(IN PSID PrefixSid, IN PSID Sid)
Definition: lookup.c:1004
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:3693
SAMPR_HANDLE
void * SAMPR_HANDLE
Definition: lookup.c:17
LsapSplitNames
static NTSTATUS LsapSplitNames(DWORD Count, PRPC_UNICODE_STRING Names, PRPC_UNICODE_STRING *DomainNames, PRPC_UNICODE_STRING *AccountNames)
Definition: lookup.c:773
CreateSidFromSidAndRid
static PSID CreateSidFromSidAndRid(PSID SrcSid, ULONG RelativeId)
Definition: lookup.c:1050
LsapLookupAccountNames
static NTSTATUS LsapLookupAccountNames(DWORD Count, PRPC_UNICODE_STRING DomainNames, PRPC_UNICODE_STRING AccountNames, PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer, PLSAPR_TRANSLATED_SID_EX2 SidsBuffer, PULONG Mapped)
Definition: lookup.c:1717
LsapCreateSid
BOOLEAN LsapCreateSid(PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, UCHAR SubAuthorityCount, PULONG SubAuthorities, PWSTR AccountName, PWSTR DomainName, SID_NAME_USE Use, PSID *SidPtr)
Definition: lookup.c:90
LsapLookupIsolatedAccountNames
static NTSTATUS LsapLookupIsolatedAccountNames(DWORD Count, PRPC_UNICODE_STRING DomainNames, PRPC_UNICODE_STRING AccountNames, PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer, PLSAPR_TRANSLATED_SID_EX2 SidsBuffer, PULONG Mapped)
Definition: lookup.c:1414
LsapLookupAccountDomainSids
static NTSTATUS LsapLookupAccountDomainSids(PLSAPR_SID_ENUM_BUFFER SidEnumBuffer, PLSAPR_TRANSLATED_NAME_EX NamesBuffer, PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer, PULONG Mapped)
Definition: lookup.c:2273
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:3464
SamrOpenDomain
NTSTATUS NTAPI SamrOpenDomain(IN SAMPR_HANDLE ServerHandle, IN ACCESS_MASK DesiredAccess, IN PRPC_SID DomainId, OUT SAMPR_HANDLE *DomainHandle)
Definition: samrpc.c:831
LsapWorldSid
PSID LsapWorldSid
Definition: lookup.c:78
PSAMPR_SERVER_NAME
wchar_t * PSAMPR_SERVER_NAME
Definition: lookup.c:16
SamrCloseHandle
NTSTATUS NTAPI SamrCloseHandle(IN OUT SAMPR_HANDLE *SamHandle)
Definition: samrpc.c:161
LsapLookupSids
NTSTATUS LsapLookupSids(PLSAPR_SID_ENUM_BUFFER SidEnumBuffer, PLSAPR_REFERENCED_DOMAIN_LIST *ReferencedDomains, PLSAPR_TRANSLATED_NAMES_EX TranslatedNames, LSAP_LOOKUP_LEVEL LookupLevel, DWORD *MappedCount, DWORD LookupOptions, DWORD ClientRevision)
Definition: lookup.c:2412
LsapBatchSid
PSID LsapBatchSid
Definition: lookup.c:80
LsapLookupIsolatedNames
static NTSTATUS LsapLookupIsolatedNames(DWORD Count, PRPC_UNICODE_STRING DomainNames, PRPC_UNICODE_STRING AccountNames, PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer, PLSAPR_TRANSLATED_SID_EX2 SidsBuffer, PULONG Mapped)
Definition: lookup.c:1154
LsapInteractiveSid
PSID LsapInteractiveSid
Definition: lookup.c:81
LsapLocalSystemSid
PSID LsapLocalSystemSid
Definition: lookup.c:83
PWELL_KNOWN_SID
struct _WELL_KNOWN_SID * PWELL_KNOWN_SID
LsapLookupIsolatedBuiltinNames
static NTSTATUS LsapLookupIsolatedBuiltinNames(DWORD Count, PRPC_UNICODE_STRING DomainNames, PRPC_UNICODE_STRING AccountNames, PLSAPR_REFERENCED_DOMAIN_LIST DomainsBuffer, PLSAPR_TRANSLATED_SID_EX2 SidsBuffer, PULONG Mapped)
Definition: lookup.c:1318
WELL_KNOWN_SID
struct _WELL_KNOWN_SID WELL_KNOWN_SID
SamIFree_SAMPR_RETURNED_USTRING_ARRAY
VOID NTAPI SamIFree_SAMPR_RETURNED_USTRING_ARRAY(PSAMPR_RETURNED_USTRING_ARRAY Ptr)
Definition: samsrv.c:486
SamrConnect
NTSTATUS NTAPI SamrConnect(IN PSAMPR_SERVER_NAME ServerName, OUT SAMPR_HANDLE *ServerHandle, IN ACCESS_MASK DesiredAccess)
Definition: samrpc.c:135
LsapInitSids
NTSTATUS LsapInitSids(VOID)
Definition: lookup.c:182
LsapAddDomainToDomainsList
static NTSTATUS LsapAddDomainToDomainsList(PLSAPR_REFERENCED_DOMAIN_LIST ReferencedDomains, PUNICODE_STRING Name, PSID Sid, PULONG Index)
Definition: lookup.c:905
LsapLoadString
INT LsapLoadString(HINSTANCE hInstance, UINT uId, LPWSTR lpBuffer, INT nBufferMax)
Definition: utils.c:17
IDS_PRINCIPAL_SELF_RID
#define IDS_PRINCIPAL_SELF_RID
Definition: resources.h:28
IDS_NULL_RID
#define IDS_NULL_RID
Definition: resources.h:13
IDS_BATCH_RID
#define IDS_BATCH_RID
Definition: resources.h:22
IDS_ALIAS_RID_ADMINS
#define IDS_ALIAS_RID_ADMINS
Definition: resources.h:38
IDS_ALIAS_RID_RAS_SERVERS
#define IDS_ALIAS_RID_RAS_SERVERS
Definition: resources.h:47
IDS_TERMINAL_SERVER_RID
#define IDS_TERMINAL_SERVER_RID
Definition: resources.h:31
IDS_LOCAL_RID
#define IDS_LOCAL_RID
Definition: resources.h:15
IDS_ALIAS_RID_POWER_USERS
#define IDS_ALIAS_RID_POWER_USERS
Definition: resources.h:41
IDS_ALIAS_RID_PREW2KCOMPACCESS
#define IDS_ALIAS_RID_PREW2KCOMPACCESS
Definition: resources.h:48
IDS_REMOTE_LOGON_RID
#define IDS_REMOTE_LOGON_RID
Definition: resources.h:32
IDS_CREATOR_GROUP_RID
#define IDS_CREATOR_GROUP_RID
Definition: resources.h:17
IDS_CREATOR_OWNER_SERVER_RID
#define IDS_CREATOR_OWNER_SERVER_RID
Definition: resources.h:18
IDS_ALIAS_RID_GUESTS
#define IDS_ALIAS_RID_GUESTS
Definition: resources.h:40
IDS_RESTRICTED_CODE_RID
#define IDS_RESTRICTED_CODE_RID
Definition: resources.h:30
IDS_ALIAS_RID_ACCOUNT_OPS
#define IDS_ALIAS_RID_ACCOUNT_OPS
Definition: resources.h:42
IDS_CREATOR_GROUP_SERVER_RID
#define IDS_CREATOR_GROUP_SERVER_RID
Definition: resources.h:19
IDS_NT_AUTHORITY
#define IDS_NT_AUTHORITY
Definition: resources.h:11
IDS_NETWORK_SERVICE_RID
#define IDS_NETWORK_SERVICE_RID
Definition: resources.h:36
IDS_ALIAS_RID_USERS
#define IDS_ALIAS_RID_USERS
Definition: resources.h:39
IDS_AUTHENTICATED_USER_RID
#define IDS_AUTHENTICATED_USER_RID
Definition: resources.h:29
IDS_ANONYMOUS_LOGON_RID
#define IDS_ANONYMOUS_LOGON_RID
Definition: resources.h:25
IDS_ENTERPRISE_CONTROLLERS_RID
#define IDS_ENTERPRISE_CONTROLLERS_RID
Definition: resources.h:27
IDS_ALIAS_RID_PRINT_OPS
#define IDS_ALIAS_RID_PRINT_OPS
Definition: resources.h:44
IDS_BUILTIN_DOMAIN_RID
#define IDS_BUILTIN_DOMAIN_RID
Definition: resources.h:37
IDS_NETWORK_RID
#define IDS_NETWORK_RID
Definition: resources.h:21
IDS_SERVICE_RID
#define IDS_SERVICE_RID
Definition: resources.h:24
IDS_LOCAL_SERVICE_RID
#define IDS_LOCAL_SERVICE_RID
Definition: resources.h:35
IDS_THIS_ORGANIZATION_RID
#define IDS_THIS_ORGANIZATION_RID
Definition: resources.h:33
IDS_PROXY_RID
#define IDS_PROXY_RID
Definition: resources.h:26
IDS_DIALUP_RID
#define IDS_DIALUP_RID
Definition: resources.h:20
IDS_INTERACTIVE_RID
#define IDS_INTERACTIVE_RID
Definition: resources.h:23
IDS_WORLD_RID
#define IDS_WORLD_RID
Definition: resources.h:14
IDS_ALIAS_RID_REMOTE_DESKTOP_USERS
#define IDS_ALIAS_RID_REMOTE_DESKTOP_USERS
Definition: resources.h:49
IDS_CREATOR_OWNER_RID
#define IDS_CREATOR_OWNER_RID
Definition: resources.h:16
IDS_ALIAS_RID_SYSTEM_OPS
#define IDS_ALIAS_RID_SYSTEM_OPS
Definition: resources.h:43
IDS_LOCAL_SYSTEM_RID
#define IDS_LOCAL_SYSTEM_RID
Definition: resources.h:34
IDS_ALIAS_RID_REPLICATOR
#define IDS_ALIAS_RID_REPLICATOR
Definition: resources.h:46
IDS_ALIAS_RID_NETWORK_CONFIGURATION_OPS
#define IDS_ALIAS_RID_NETWORK_CONFIGURATION_OPS
Definition: resources.h:50
IDS_ALIAS_RID_BACKUP_OPS
#define IDS_ALIAS_RID_BACKUP_OPS
Definition: resources.h:45
L
#define L(x)
Definition: resources.c:13
InsertTailList
#define InsertTailList(ListHead, Entry)
Definition: env_spec_w32.h:1003
InitializeListHead
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
Ptr
_Must_inspect_result_ _In_ PFSRTL_PER_STREAM_CONTEXT Ptr
Definition: fsrtlfuncs.h:898
Status
Status
Definition: gdiplustypes.h:25
q
GLdouble GLdouble GLdouble GLdouble q
Definition: gl.h:2063
p
GLfloat GLfloat p
Definition: glext.h:8902
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
LocalFree
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
wcslen
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
RtlCopySid
NTSYSAPI BOOLEAN WINAPI RtlCopySid(DWORD, PSID, PSID)
MIDL_user_allocate
void *__RPC_USER MIDL_user_allocate(SIZE_T size)
Definition: irotp.c:371
MIDL_user_free
void __RPC_USER MIDL_user_free(void *p)
Definition: irotp.c:376
SID_NAME_USE
enum _SID_NAME_USE SID_NAME_USE
LSAPR_TRANSLATED_SID_EX2
struct _LSAPR_TRANSLATED_SID_EX2 LSAPR_TRANSLATED_SID_EX2
LSAPR_TRANSLATED_NAME_EX
struct _LSAPR_TRANSLATED_NAME_EX LSAPR_TRANSLATED_NAME_EX
LSAP_LOOKUP_LEVEL
enum _LSAP_LOOKUP_LEVEL LSAP_LOOKUP_LEVEL
SidTypeUnknown
@ SidTypeUnknown
Definition: lsa.idl:125
SidTypeAlias
@ SidTypeAlias
Definition: lsa.idl:121
SidTypeDomain
@ SidTypeDomain
Definition: lsa.idl:120
SidTypeWellKnownGroup
@ SidTypeWellKnownGroup
Definition: lsa.idl:122
ptr
static PVOID ptr
Definition: dispmode.c:27
Entries
static const ENTRY Entries[]
Definition: MultiByteToWideChar.c:42
resources.h
RtlSubAuthoritySid
NTSYSAPI PULONG NTAPI RtlSubAuthoritySid(_In_ PSID Sid, _In_ ULONG SubAuthority)
RtlLengthRequiredSid
NTSYSAPI ULONG NTAPI RtlLengthRequiredSid(IN ULONG SubAuthorityCount)
Definition: sid.c:54
SubAuthorityCount
_In_ PSID_IDENTIFIER_AUTHORITY _In_ UCHAR SubAuthorityCount
Definition: rtlfuncs.h:1539
RtlLengthSid
NTSYSAPI ULONG NTAPI RtlLengthSid(IN PSID Sid)
Definition: sid.c:150
Sid
_In_ ULONG _In_ ACCESS_MASK _In_ PSID Sid
Definition: rtlfuncs.h:1157
RtlIdentifierAuthoritySid
NTSYSAPI PSID_IDENTIFIER_AUTHORITY NTAPI RtlIdentifierAuthoritySid(PSID Sid)
RtlEqualSid
NTSYSAPI BOOLEAN NTAPI RtlEqualSid(_In_ PSID Sid1, _In_ PSID Sid2)
IdentifierAuthority
_In_ PSID_IDENTIFIER_AUTHORITY IdentifierAuthority
Definition: rtlfuncs.h:1537
Count
int Count
Definition: noreturn.cpp:7
ACCESS_MASK
ULONG ACCESS_MASK
Definition: nt_native.h:40
RtlEqualUnicodeString
NTSYSAPI BOOLEAN NTAPI RtlEqualUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive)
UNICODE_NULL
#define UNICODE_NULL
UNICODE_STRING_MAX_CHARS
#define UNICODE_STRING_MAX_CHARS
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
RtlSubAuthorityCountSid
NTSYSAPI PUCHAR NTAPI RtlSubAuthorityCountSid(IN PSID Sid)
Definition: sid.c:104
RtlInitializeSid
NTSYSAPI NTSTATUS NTAPI RtlInitializeSid(IN OUT PSID Sid, IN PSID_IDENTIFIER_AUTHORITY IdentifierAuthority, IN UCHAR SubAuthorityCount)
DOMAIN_LOOKUP
#define DOMAIN_LOOKUP
Definition: ntsam.h:42
SAM_SERVER_LOOKUP_DOMAIN
#define SAM_SERVER_LOOKUP_DOMAIN
Definition: ntsam.h:104
SAM_SERVER_CONNECT
#define SAM_SERVER_CONNECT
Definition: ntsam.h:99
STATUS_NONE_MAPPED
#define STATUS_NONE_MAPPED
Definition: ntstatus.h:351
STATUS_SOME_NOT_MAPPED
#define STATUS_SOME_NOT_MAPPED
Definition: ntstatus.h:86
USHORT
unsigned short USHORT
Definition: pedump.c:61
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
TRACE
#define TRACE(s)
Definition: solgame.cpp:4
_LIST_ENTRY
Definition: typedefs.h:120
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
_LSAPR_REFERENCED_DOMAIN_LIST
Definition: lsa.idl:109
_LSAPR_REFERENCED_DOMAIN_LIST::MaxEntries
DWORD MaxEntries
Definition: lsa.idl:112
_LSAPR_REFERENCED_DOMAIN_LIST::Entries
DWORD Entries
Definition: lsa.idl:110
_LSAPR_REFERENCED_DOMAIN_LIST::Domains
PLSAPR_TRUST_INFORMATION Domains
Definition: lsa.idl:111
_LSAPR_SID_ENUM_BUFFER
Definition: lsa.idl:161
_LSAPR_SID_ENUM_BUFFER::Entries
DWORD Entries
Definition: lsa.idl:162
_LSAPR_SID_ENUM_BUFFER::SidInfo
PLSAPR_SID_INFORMATION SidInfo
Definition: lsa.idl:163
_LSAPR_SID_INFORMATION::Sid
PRPC_SID Sid
Definition: lsa.idl:158
_LSAPR_TRANSLATED_NAMES_EX
Definition: lsa.idl:184
_LSAPR_TRANSLATED_NAMES_EX::Names
PLSAPR_TRANSLATED_NAME_EX Names
Definition: lsa.idl:186
_LSAPR_TRANSLATED_NAMES_EX::Entries
DWORD Entries
Definition: lsa.idl:185
_LSAPR_TRANSLATED_NAME_EX
Definition: lsa.idl:177
_LSAPR_TRANSLATED_NAME_EX::Use
SID_NAME_USE Use
Definition: lsa.idl:178
_LSAPR_TRANSLATED_NAME_EX::DomainIndex
LONG DomainIndex
Definition: lsa.idl:180
_LSAPR_TRANSLATED_NAME_EX::Flags
DWORD Flags
Definition: lsa.idl:181
_LSAPR_TRANSLATED_NAME_EX::Name
RPC_UNICODE_STRING Name
Definition: lsa.idl:179
_LSAPR_TRANSLATED_SIDS_EX2
Definition: lsa.idl:208
_LSAPR_TRANSLATED_SIDS_EX2::Entries
DWORD Entries
Definition: lsa.idl:209
_LSAPR_TRANSLATED_SIDS_EX2::Sids
PLSAPR_TRANSLATED_SID_EX2 Sids
Definition: lsa.idl:210
_LSAPR_TRANSLATED_SID_EX2
Definition: lsa.idl:201
_LSAPR_TRANSLATED_SID_EX2::Flags
DWORD Flags
Definition: lsa.idl:205
_LSAPR_TRANSLATED_SID_EX2::Use
SID_NAME_USE Use
Definition: lsa.idl:202
_LSAPR_TRANSLATED_SID_EX2::Sid
PRPC_SID Sid
Definition: lsa.idl:203
_LSAPR_TRANSLATED_SID_EX2::DomainIndex
LONG DomainIndex
Definition: lsa.idl:204
_LSAPR_TRUST_INFORMATION::Sid
PRPC_SID Sid
Definition: lsa.idl:106
_LSAPR_TRUST_INFORMATION::Name
RPC_UNICODE_STRING Name
Definition: lsa.idl:105
_LSA_TRUST_INFORMATION
Definition: ntsecapi.h:402
_RPC_SID
Definition: msv1_0.h:13
_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_RETURNED_USTRING_ARRAY
Definition: lookup.c:20
_SAMPR_RETURNED_USTRING_ARRAY::Element
PRPC_UNICODE_STRING Element
Definition: lookup.c:22
_SAMPR_RETURNED_USTRING_ARRAY::Count
unsigned long Count
Definition: lookup.c:21
_SAMPR_ULONG_ARRAY
Definition: lsasrv.h:86
_SAMPR_ULONG_ARRAY::Element
unsigned long * Element
Definition: lsasrv.h:88
_SID_IDENTIFIER_AUTHORITY::Value
BYTE Value[6]
Definition: ms-dtyp.idl:195
_SID
Definition: ms-dtyp.idl:198
_SID::Revision
BYTE Revision
Definition: ms-dtyp.idl:199
_SID::SubAuthority
DWORD SubAuthority[*]
Definition: ms-dtyp.idl:202
_SID::SubAuthorityCount
BYTE SubAuthorityCount
Definition: ms-dtyp.idl:200
_SID::IdentifierAuthority
SID_IDENTIFIER_AUTHORITY IdentifierAuthority
Definition: ms-dtyp.idl:201
_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
_WELL_KNOWN_SID
Definition: lookup.c:68
_WELL_KNOWN_SID::AccountName
UNICODE_STRING AccountName
Definition: lookup.c:71
_WELL_KNOWN_SID::Sid
PSID Sid
Definition: lookup.c:70
_WELL_KNOWN_SID::DomainName
UNICODE_STRING DomainName
Definition: lookup.c:72
_WELL_KNOWN_SID::Use
SID_NAME_USE Use
Definition: lookup.c:73
_WELL_KNOWN_SID::ListEntry
LIST_ENTRY ListEntry
Definition: lookup.c:69
RTL_CONSTANT_STRING
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
PWSTR
uint16_t * PWSTR
Definition: typedefs.h:56
PULONG
uint32_t * PULONG
Definition: typedefs.h:59
NTAPI
#define NTAPI
Definition: typedefs.h:36
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
IN
#define IN
Definition: typedefs.h:39
CONTAINING_RECORD
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260
ULONG
uint32_t ULONG
Definition: typedefs.h:59
OUT
#define OUT
Definition: typedefs.h:40
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
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:2658
MaximumLength
_In_ WDFDMATRANSACTION _In_ size_t MaximumLength
Definition: wdfdmatransaction.h:498
CopyMemory
#define CopyMemory
Definition: winbase.h:1751
Sid2
_In_ PSID Sid2
Definition: rtlfuncs.h:1772
SECURITY_ANONYMOUS_LOGON_RID
#define SECURITY_ANONYMOUS_LOGON_RID
Definition: setypes.h:563
DOMAIN_ALIAS_RID_USERS
#define DOMAIN_ALIAS_RID_USERS
Definition: setypes.h:653
DOMAIN_ALIAS_RID_GUESTS
#define DOMAIN_ALIAS_RID_GUESTS
Definition: setypes.h:654
DOMAIN_ALIAS_RID_NETWORK_CONFIGURATION_OPS
#define DOMAIN_ALIAS_RID_NETWORK_CONFIGURATION_OPS
Definition: setypes.h:666
SECURITY_BUILTIN_DOMAIN_RID
#define SECURITY_BUILTIN_DOMAIN_RID
Definition: setypes.h:581
SECURITY_LOCAL_RID
#define SECURITY_LOCAL_RID
Definition: setypes.h:542
SECURITY_DIALUP_RID
#define SECURITY_DIALUP_RID
Definition: setypes.h:556
SECURITY_SERVICE_RID
#define SECURITY_SERVICE_RID
Definition: setypes.h:562
SECURITY_PROXY_RID
#define SECURITY_PROXY_RID
Definition: setypes.h:564
SECURITY_INTERACTIVE_RID
#define SECURITY_INTERACTIVE_RID
Definition: setypes.h:559
SECURITY_WORLD_RID
#define SECURITY_WORLD_RID
Definition: setypes.h:541
SECURITY_CREATOR_GROUP_SERVER_RID
#define SECURITY_CREATOR_GROUP_SERVER_RID
Definition: setypes.h:548
DOMAIN_ALIAS_RID_REMOTE_DESKTOP_USERS
#define DOMAIN_ALIAS_RID_REMOTE_DESKTOP_USERS
Definition: setypes.h:665
DOMAIN_ALIAS_RID_SYSTEM_OPS
#define DOMAIN_ALIAS_RID_SYSTEM_OPS
Definition: setypes.h:658
SECURITY_LOCAL_SYSTEM_RID
#define SECURITY_LOCAL_SYSTEM_RID
Definition: setypes.h:574
SECURITY_AUTHENTICATED_USER_RID
#define SECURITY_AUTHENTICATED_USER_RID
Definition: setypes.h:568
SECURITY_NULL_RID
#define SECURITY_NULL_RID
Definition: setypes.h:540
DOMAIN_ALIAS_RID_ACCOUNT_OPS
#define DOMAIN_ALIAS_RID_ACCOUNT_OPS
Definition: setypes.h:657
SECURITY_RESTRICTED_CODE_RID
#define SECURITY_RESTRICTED_CODE_RID
Definition: setypes.h:569
DOMAIN_ALIAS_RID_RAS_SERVERS
#define DOMAIN_ALIAS_RID_RAS_SERVERS
Definition: setypes.h:663
SECURITY_TERMINAL_SERVER_RID
#define SECURITY_TERMINAL_SERVER_RID
Definition: setypes.h:570
DOMAIN_ALIAS_RID_BACKUP_OPS
#define DOMAIN_ALIAS_RID_BACKUP_OPS
Definition: setypes.h:660
SECURITY_BATCH_RID
#define SECURITY_BATCH_RID
Definition: setypes.h:558
DOMAIN_ALIAS_RID_PRINT_OPS
#define DOMAIN_ALIAS_RID_PRINT_OPS
Definition: setypes.h:659
SECURITY_CREATOR_OWNER_SERVER_RID
#define SECURITY_CREATOR_OWNER_SERVER_RID
Definition: setypes.h:547
DOMAIN_ALIAS_RID_REPLICATOR
#define DOMAIN_ALIAS_RID_REPLICATOR
Definition: setypes.h:662
SECURITY_LOCAL_SERVICE_RID
#define SECURITY_LOCAL_SERVICE_RID
Definition: setypes.h:575
SECURITY_THIS_ORGANIZATION_RID
#define SECURITY_THIS_ORGANIZATION_RID
Definition: setypes.h:572
SECURITY_PRINCIPAL_SELF_RID
#define SECURITY_PRINCIPAL_SELF_RID
Definition: setypes.h:567
PSID_IDENTIFIER_AUTHORITY
* PSID_IDENTIFIER_AUTHORITY
Definition: setypes.h:464
SECURITY_CREATOR_OWNER_RID
#define SECURITY_CREATOR_OWNER_RID
Definition: setypes.h:545
DOMAIN_ALIAS_RID_POWER_USERS
#define DOMAIN_ALIAS_RID_POWER_USERS
Definition: setypes.h:655
DOMAIN_ALIAS_RID_PREW2KCOMPACCESS
#define DOMAIN_ALIAS_RID_PREW2KCOMPACCESS
Definition: setypes.h:664
SECURITY_ENTERPRISE_CONTROLLERS_RID
#define SECURITY_ENTERPRISE_CONTROLLERS_RID
Definition: setypes.h:565
SECURITY_NETWORK_RID
#define SECURITY_NETWORK_RID
Definition: setypes.h:557
SECURITY_NETWORK_SERVICE_RID
#define SECURITY_NETWORK_SERVICE_RID
Definition: setypes.h:576
DOMAIN_ALIAS_RID_ADMINS
#define DOMAIN_ALIAS_RID_ADMINS
Definition: setypes.h:652
SECURITY_REMOTE_LOGON_RID
#define SECURITY_REMOTE_LOGON_RID
Definition: setypes.h:571
SECURITY_CREATOR_GROUP_RID
#define SECURITY_CREATOR_GROUP_RID
Definition: setypes.h:546
UCHAR
unsigned char UCHAR
Definition: xmlstorage.h:181
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
LPWSTR
WCHAR * LPWSTR
Definition: xmlstorage.h:184