?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 20050930.
[wine/gsoc-2012-control.git] / dlls / advapi32 / security.c
blob605266dea53e85223d1c1cb84965ea230ec87d73
1 /*
2 * Copyright 1999, 2000 Juergen Schmied <juergen.schmied@debitel.net>
3 * Copyright 2003 CodeWeavers Inc. (Ulrich Czekalla)
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 *
19 */
20
21 #include <stdarg.h>
22 #include <string.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winerror.h"
27 #include "rpcnterr.h"
28 #include "winreg.h"
29 #include "winternl.h"
30 #include "winioctl.h"
31 #include "ntstatus.h"
32 #include "ntsecapi.h"
33 #include "accctrl.h"
34 #include "sddl.h"
35 #include "winsvc.h"
36 #include "aclapi.h"
37
38 #include "wine/debug.h"
39 #include "wine/unicode.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
42
43 static BOOL ParseStringSidToSid(LPCWSTR StringSid, PSID pSid, LPDWORD cBytes);
44 static BOOL ParseStringAclToAcl(LPCWSTR StringAcl, LPDWORD lpdwFlags,
45 PACL pAcl, LPDWORD cBytes);
46 static BYTE ParseAceStringFlags(LPCWSTR* StringAcl);
47 static BYTE ParseAceStringType(LPCWSTR* StringAcl);
48 static DWORD ParseAceStringRights(LPCWSTR* StringAcl);
49 static BOOL ParseStringSecurityDescriptorToSecurityDescriptor(
50 LPCWSTR StringSecurityDescriptor,
51 SECURITY_DESCRIPTOR* SecurityDescriptor,
52 LPDWORD cBytes);
53 static DWORD ParseAclStringFlags(LPCWSTR* StringAcl);
54
55 typedef struct _ACEFLAG
56 {
57 LPCWSTR wstr;
58 DWORD value;
59 } ACEFLAG, *LPACEFLAG;
60
61 static SID const sidWorld = { SID_REVISION, 1, { SECURITY_WORLD_SID_AUTHORITY} , { SECURITY_WORLD_RID } };
62
63 /*
64 * ACE access rights
65 */
66 static const WCHAR SDDL_READ_CONTROL[] = {'R','C',0};
67 static const WCHAR SDDL_WRITE_DAC[] = {'W','D',0};
68 static const WCHAR SDDL_WRITE_OWNER[] = {'W','O',0};
69 static const WCHAR SDDL_STANDARD_DELETE[] = {'S','D',0};
70 static const WCHAR SDDL_GENERIC_ALL[] = {'G','A',0};
71 static const WCHAR SDDL_GENERIC_READ[] = {'G','R',0};
72 static const WCHAR SDDL_GENERIC_WRITE[] = {'G','W',0};
73 static const WCHAR SDDL_GENERIC_EXECUTE[] = {'G','X',0};
74
75 /*
76 * ACE types
77 */
78 static const WCHAR SDDL_ACCESS_ALLOWED[] = {'A',0};
79 static const WCHAR SDDL_ACCESS_DENIED[] = {'D',0};
80 static const WCHAR SDDL_OBJECT_ACCESS_ALLOWED[] = {'O','A',0};
81 static const WCHAR SDDL_OBJECT_ACCESS_DENIED[] = {'O','D',0};
82 static const WCHAR SDDL_AUDIT[] = {'A','U',0};
83 static const WCHAR SDDL_ALARM[] = {'A','L',0};
84 static const WCHAR SDDL_OBJECT_AUDIT[] = {'O','U',0};
85 static const WCHAR SDDL_OBJECT_ALARMp[] = {'O','L',0};
86
87 /*
88 * ACE flags
89 */
90 static const WCHAR SDDL_CONTAINER_INHERIT[] = {'C','I',0};
91 static const WCHAR SDDL_OBJECT_INHERIT[] = {'O','I',0};
92 static const WCHAR SDDL_NO_PROPAGATE[] = {'N','P',0};
93 static const WCHAR SDDL_INHERIT_ONLY[] = {'I','O',0};
94 static const WCHAR SDDL_INHERITED[] = {'I','D',0};
95 static const WCHAR SDDL_AUDIT_SUCCESS[] = {'S','A',0};
96 static const WCHAR SDDL_AUDIT_FAILURE[] = {'F','A',0};
97
98 /* set last error code from NT status and get the proper boolean return value */
99 /* used for functions that are a simple wrapper around the corresponding ntdll API */
100 static inline BOOL set_ntstatus( NTSTATUS status )
101 {
102 if (status) SetLastError( RtlNtStatusToDosError( status ));
103 return !status;
104 }
105
106 #define WINE_SIZE_OF_WORLD_ACCESS_ACL (sizeof(ACL) + sizeof(ACCESS_ALLOWED_ACE) + sizeof(sidWorld) - sizeof(DWORD))
107
108 static void GetWorldAccessACL(PACL pACL)
109 {
110 PACCESS_ALLOWED_ACE pACE = (PACCESS_ALLOWED_ACE) (pACL + 1);
111
112 pACL->AclRevision = ACL_REVISION;
113 pACL->Sbz1 = 0;
114 pACL->AclSize = WINE_SIZE_OF_WORLD_ACCESS_ACL;
115 pACL->AceCount = 1;
116 pACL->Sbz2 = 0;
117
118 pACE->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
119 pACE->Header.AceFlags = CONTAINER_INHERIT_ACE;
120 pACE->Header.AceSize = sizeof(ACCESS_ALLOWED_ACE) + sizeof(sidWorld) - sizeof(DWORD);
121 pACE->Mask = 0xf3ffffff; /* Everything except reserved bits */
122 memcpy(&pACE->SidStart, &sidWorld, sizeof(sidWorld));
123 }
124
125 /************************************************************
126 * ADVAPI_IsLocalComputer
127 *
128 * Checks whether the server name indicates local machine.
129 */
130 static BOOL ADVAPI_IsLocalComputer(LPCWSTR ServerName)
131 {
132 DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
133 BOOL Result;
134 LPWSTR buf;
135
136 if (!ServerName || !ServerName[0])
137 return TRUE;
138
139 buf = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
140 Result = GetComputerNameW(buf, &dwSize);
141 if (Result && (ServerName[0] == '\\') && (ServerName[1] == '\\'))
142 ServerName += 2;
143 Result = Result && !lstrcmpW(ServerName, buf);
144 HeapFree(GetProcessHeap(), 0, buf);
145
146 return Result;
147 }
148
149 /* ##############################
150 ###### TOKEN FUNCTIONS ######
151 ##############################
152 */
153
154 /******************************************************************************
155 * OpenProcessToken [ADVAPI32.@]
156 * Opens the access token associated with a process handle.
157 *
158 * PARAMS
159 * ProcessHandle [I] Handle to process
160 * DesiredAccess [I] Desired access to process
161 * TokenHandle [O] Pointer to handle of open access token
162 *
163 * RETURNS
164 * Success: TRUE. TokenHandle contains the access token.
165 * Failure: FALSE.
166 *
167 * NOTES
168 * See NtOpenProcessToken.
169 */
170 BOOL WINAPI
171 OpenProcessToken( HANDLE ProcessHandle, DWORD DesiredAccess,
172 HANDLE *TokenHandle )
173 {
174 return set_ntstatus(NtOpenProcessToken( ProcessHandle, DesiredAccess, TokenHandle ));
175 }
176
177 /******************************************************************************
178 * OpenThreadToken [ADVAPI32.@]
179 *
180 * Opens the access token associated with a thread handle.
181 *
182 * PARAMS
183 * ThreadHandle [I] Handle to process
184 * DesiredAccess [I] Desired access to the thread
185 * OpenAsSelf [I] ???
186 * TokenHandle [O] Destination for the token handle
187 *
188 * RETURNS
189 * Success: TRUE. TokenHandle contains the access token.
190 * Failure: FALSE.
191 *
192 * NOTES
193 * See NtOpenThreadToken.
194 */
195 BOOL WINAPI
196 OpenThreadToken( HANDLE ThreadHandle, DWORD DesiredAccess,
197 BOOL OpenAsSelf, HANDLE *TokenHandle)
198 {
199 return set_ntstatus( NtOpenThreadToken(ThreadHandle, DesiredAccess, OpenAsSelf, TokenHandle));
200 }
201
202 BOOL WINAPI
203 AdjustTokenGroups( HANDLE TokenHandle, BOOL ResetToDefault, PTOKEN_GROUPS NewState,
204 DWORD BufferLength, PTOKEN_GROUPS PreviousState, PDWORD ReturnLength )
205 {
206 return set_ntstatus( NtAdjustGroupsToken(TokenHandle, ResetToDefault, NewState, BufferLength,
207 PreviousState, ReturnLength));
208 }
209
210 /******************************************************************************
211 * AdjustTokenPrivileges [ADVAPI32.@]
212 *
213 * Adjust the privileges of an open token handle.
214 *
215 * PARAMS
216 * TokenHandle [I] Handle from OpenProcessToken() or OpenThreadToken()
217 * DisableAllPrivileges [I] TRUE=Remove all privileges, FALSE=Use NewState
218 * NewState [I] Desired new privileges of the token
219 * BufferLength [I] Length of NewState
220 * PreviousState [O] Destination for the previous state
221 * ReturnLength [I/O] Size of PreviousState
222 *
223 *
224 * RETURNS
225 * Success: TRUE. Privileges are set to NewState and PreviousState is updated.
226 * Failure: FALSE.
227 *
228 * NOTES
229 * See NtAdjustPrivilegesToken.
230 */
231 BOOL WINAPI
232 AdjustTokenPrivileges( HANDLE TokenHandle, BOOL DisableAllPrivileges,
233 LPVOID NewState, DWORD BufferLength,
234 LPVOID PreviousState, LPDWORD ReturnLength )
235 {
236 NTSTATUS status;
237
238 TRACE("\n");
239
240 status = NtAdjustPrivilegesToken(TokenHandle, DisableAllPrivileges,
241 NewState, BufferLength, PreviousState,
242 ReturnLength);
243 SetLastError( RtlNtStatusToDosError( status ));
244 if ((status == STATUS_SUCCESS) || (status == STATUS_NOT_ALL_ASSIGNED))
245 return TRUE;
246 else
247 return FALSE;
248 }
249
250 /******************************************************************************
251 * CheckTokenMembership [ADVAPI32.@]
252 *
253 * Determine if an access token is a member of a SID.
254 *
255 * PARAMS
256 * TokenHandle [I] Handle from OpenProcessToken() or OpenThreadToken()
257 * SidToCheck [I] SID that possibly contains the token
258 * IsMember [O] Destination for result.
259 *
260 * RETURNS
261 * Success: TRUE. IsMember is TRUE if TokenHandle is a member, FALSE otherwise.
262 * Failure: FALSE.
263 */
264 BOOL WINAPI
265 CheckTokenMembership( HANDLE TokenHandle, PSID SidToCheck,
266 PBOOL IsMember )
267 {
268 FIXME("(%p %p %p) stub!\n", TokenHandle, SidToCheck, IsMember);
269
270 *IsMember = TRUE;
271 return(TRUE);
272 }
273
274 /******************************************************************************
275 * GetTokenInformation [ADVAPI32.@]
276 *
277 * PARAMS
278 * token [I] Handle from OpenProcessToken() or OpenThreadToken()
279 * tokeninfoclass [I] A TOKEN_INFORMATION_CLASS from "winnt.h"
280 * tokeninfo [O] Destination for token information
281 * tokeninfolength [I] Length of tokeninfo
282 * retlen [O] Destination for returned token information length
283 *
284 * RETURNS
285 * Success: TRUE. tokeninfo contains retlen bytes of token information
286 * Failure: FALSE.
287 *
288 * NOTES
289 * See NtQueryInformationToken.
290 */
291 BOOL WINAPI
292 GetTokenInformation( HANDLE token, TOKEN_INFORMATION_CLASS tokeninfoclass,
293 LPVOID tokeninfo, DWORD tokeninfolength, LPDWORD retlen )
294 {
295 TRACE("(%p, %s, %p, %ld, %p): \n",
296 token,
297 (tokeninfoclass == TokenUser) ? "TokenUser" :
298 (tokeninfoclass == TokenGroups) ? "TokenGroups" :
299 (tokeninfoclass == TokenPrivileges) ? "TokenPrivileges" :
300 (tokeninfoclass == TokenOwner) ? "TokenOwner" :
301 (tokeninfoclass == TokenPrimaryGroup) ? "TokenPrimaryGroup" :
302 (tokeninfoclass == TokenDefaultDacl) ? "TokenDefaultDacl" :
303 (tokeninfoclass == TokenSource) ? "TokenSource" :
304 (tokeninfoclass == TokenType) ? "TokenType" :
305 (tokeninfoclass == TokenImpersonationLevel) ? "TokenImpersonationLevel" :
306 (tokeninfoclass == TokenStatistics) ? "TokenStatistics" :
307 (tokeninfoclass == TokenRestrictedSids) ? "TokenRestrictedSids" :
308 (tokeninfoclass == TokenSessionId) ? "TokenSessionId" :
309 (tokeninfoclass == TokenGroupsAndPrivileges) ? "TokenGroupsAndPrivileges" :
310 (tokeninfoclass == TokenSessionReference) ? "TokenSessionReference" :
311 (tokeninfoclass == TokenSandBoxInert) ? "TokenSandBoxInert" :
312 "Unknown",
313 tokeninfo, tokeninfolength, retlen);
314 return set_ntstatus( NtQueryInformationToken( token, tokeninfoclass, tokeninfo,
315 tokeninfolength, retlen));
316 }
317
318 /******************************************************************************
319 * SetTokenInformation [ADVAPI32.@]
320 *
321 * Set information for an access token.
322 *
323 * PARAMS
324 * token [I] Handle from OpenProcessToken() or OpenThreadToken()
325 * tokeninfoclass [I] A TOKEN_INFORMATION_CLASS from "winnt.h"
326 * tokeninfo [I] Token information to set
327 * tokeninfolength [I] Length of tokeninfo
328 *
329 * RETURNS
330 * Success: TRUE. The information for the token is set to tokeninfo.
331 * Failure: FALSE.
332 */
333 BOOL WINAPI
334 SetTokenInformation( HANDLE token, TOKEN_INFORMATION_CLASS tokeninfoclass,
335 LPVOID tokeninfo, DWORD tokeninfolength )
336 {
337 TRACE("(%p, %s, %p, %ld): stub\n",
338 token,
339 (tokeninfoclass == TokenUser) ? "TokenUser" :
340 (tokeninfoclass == TokenGroups) ? "TokenGroups" :
341 (tokeninfoclass == TokenPrivileges) ? "TokenPrivileges" :
342 (tokeninfoclass == TokenOwner) ? "TokenOwner" :
343 (tokeninfoclass == TokenPrimaryGroup) ? "TokenPrimaryGroup" :
344 (tokeninfoclass == TokenDefaultDacl) ? "TokenDefaultDacl" :
345 (tokeninfoclass == TokenSource) ? "TokenSource" :
346 (tokeninfoclass == TokenType) ? "TokenType" :
347 (tokeninfoclass == TokenImpersonationLevel) ? "TokenImpersonationLevel" :
348 (tokeninfoclass == TokenStatistics) ? "TokenStatistics" :
349 (tokeninfoclass == TokenRestrictedSids) ? "TokenRestrictedSids" :
350 (tokeninfoclass == TokenSessionId) ? "TokenSessionId" :
351 (tokeninfoclass == TokenGroupsAndPrivileges) ? "TokenGroupsAndPrivileges" :
352 (tokeninfoclass == TokenSessionReference) ? "TokenSessionReference" :
353 (tokeninfoclass == TokenSandBoxInert) ? "TokenSandBoxInert" :
354 "Unknown",
355 tokeninfo, tokeninfolength);
356
357 return set_ntstatus( NtSetInformationToken( token, tokeninfoclass, tokeninfo, tokeninfolength ));
358 }
359
360 /*************************************************************************
361 * SetThreadToken [ADVAPI32.@]
362 *
363 * Assigns an 'impersonation token' to a thread so it can assume the
364 * security privileges of another thread or process. Can also remove
365 * a previously assigned token.
366 *
367 * PARAMS
368 * thread [O] Handle to thread to set the token for
369 * token [I] Token to set
370 *
371 * RETURNS
372 * Success: TRUE. The threads access token is set to token
373 * Failure: FALSE.
374 *
375 * NOTES
376 * Only supported on NT or higher. On Win9X this function does nothing.
377 * See SetTokenInformation.
378 */
379 BOOL WINAPI SetThreadToken(PHANDLE thread, HANDLE token)
380 {
381 return set_ntstatus( NtSetInformationThread( thread ? *thread : GetCurrentThread(),
382 ThreadImpersonationToken, &token, sizeof token ));
383 }
384
385 /* ##############################
386 ###### SID FUNCTIONS ######
387 ##############################
388 */
389
390 /******************************************************************************
391 * AllocateAndInitializeSid [ADVAPI32.@]
392 *
393 * PARAMS
394 * pIdentifierAuthority []
395 * nSubAuthorityCount []
396 * nSubAuthority0 []
397 * nSubAuthority1 []
398 * nSubAuthority2 []
399 * nSubAuthority3 []
400 * nSubAuthority4 []
401 * nSubAuthority5 []
402 * nSubAuthority6 []
403 * nSubAuthority7 []
404 * pSid []
405 */
406 BOOL WINAPI
407 AllocateAndInitializeSid( PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
408 BYTE nSubAuthorityCount,
409 DWORD nSubAuthority0, DWORD nSubAuthority1,
410 DWORD nSubAuthority2, DWORD nSubAuthority3,
411 DWORD nSubAuthority4, DWORD nSubAuthority5,
412 DWORD nSubAuthority6, DWORD nSubAuthority7,
413 PSID *pSid )
414 {
415 return set_ntstatus( RtlAllocateAndInitializeSid(
416 pIdentifierAuthority, nSubAuthorityCount,
417 nSubAuthority0, nSubAuthority1, nSubAuthority2, nSubAuthority3,
418 nSubAuthority4, nSubAuthority5, nSubAuthority6, nSubAuthority7,
419 pSid ));
420 }
421
422 /******************************************************************************
423 * FreeSid [ADVAPI32.@]
424 *
425 * PARAMS
426 * pSid []
427 */
428 PVOID WINAPI
429 FreeSid( PSID pSid )
430 {
431 RtlFreeSid(pSid);
432 return NULL; /* is documented like this */
433 }
434
435 /******************************************************************************
436 * CopySid [ADVAPI32.@]
437 *
438 * PARAMS
439 * nDestinationSidLength []
440 * pDestinationSid []
441 * pSourceSid []
442 */
443 BOOL WINAPI
444 CopySid( DWORD nDestinationSidLength, PSID pDestinationSid, PSID pSourceSid )
445 {
446 return RtlCopySid(nDestinationSidLength, pDestinationSid, pSourceSid);
447 }
448
449 BOOL WINAPI
450 IsTokenRestricted( HANDLE TokenHandle )
451 {
452 TOKEN_GROUPS *groups;
453 DWORD size;
454 NTSTATUS status;
455 BOOL restricted;
456
457 TRACE("(%p)\n", TokenHandle);
458
459 status = NtQueryInformationToken(TokenHandle, TokenRestrictedSids, NULL, 0, &size);
460 if (status != STATUS_BUFFER_TOO_SMALL)
461 return FALSE;
462
463 groups = HeapAlloc(GetProcessHeap(), 0, size);
464 if (!groups)
465 {
466 SetLastError(ERROR_OUTOFMEMORY);
467 return FALSE;
468 }
469
470 status = NtQueryInformationToken(TokenHandle, TokenRestrictedSids, groups, size, &size);
471 if (status != STATUS_SUCCESS)
472 {
473 HeapFree(GetProcessHeap(), 0, groups);
474 return set_ntstatus(status);
475 }
476
477 if (groups->GroupCount)
478 restricted = TRUE;
479 else
480 restricted = FALSE;
481
482 HeapFree(GetProcessHeap(), 0, groups);
483
484 return restricted;
485 }
486
487 /******************************************************************************
488 * IsValidSid [ADVAPI32.@]
489 *
490 * PARAMS
491 * pSid []
492 */
493 BOOL WINAPI
494 IsValidSid( PSID pSid )
495 {
496 return RtlValidSid( pSid );
497 }
498
499 /******************************************************************************
500 * EqualSid [ADVAPI32.@]
501 *
502 * PARAMS
503 * pSid1 []
504 * pSid2 []
505 */
506 BOOL WINAPI
507 EqualSid( PSID pSid1, PSID pSid2 )
508 {
509 return RtlEqualSid( pSid1, pSid2 );
510 }
511
512 /******************************************************************************
513 * EqualPrefixSid [ADVAPI32.@]
514 */
515 BOOL WINAPI EqualPrefixSid (PSID pSid1, PSID pSid2)
516 {
517 return RtlEqualPrefixSid(pSid1, pSid2);
518 }
519
520 /******************************************************************************
521 * GetSidLengthRequired [ADVAPI32.@]
522 *
523 * PARAMS
524 * nSubAuthorityCount []
525 */
526 DWORD WINAPI
527 GetSidLengthRequired( BYTE nSubAuthorityCount )
528 {
529 return RtlLengthRequiredSid(nSubAuthorityCount);
530 }
531
532 /******************************************************************************
533 * InitializeSid [ADVAPI32.@]
534 *
535 * PARAMS
536 * pIdentifierAuthority []
537 */
538 BOOL WINAPI
539 InitializeSid (
540 PSID pSid,
541 PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
542 BYTE nSubAuthorityCount)
543 {
544 return RtlInitializeSid(pSid, pIdentifierAuthority, nSubAuthorityCount);
545 }
546
547 DWORD WINAPI
548 GetEffectiveRightsFromAclA( PACL pacl, PTRUSTEEA pTrustee, PACCESS_MASK pAccessRights )
549 {
550 FIXME("%p %p %p - stub\n", pacl, pTrustee, pAccessRights);
551
552 return 1;
553 }
554
555 DWORD WINAPI
556 GetEffectiveRightsFromAclW( PACL pacl, PTRUSTEEW pTrustee, PACCESS_MASK pAccessRights )
557 {
558 FIXME("%p %p %p - stub\n", pacl, pTrustee, pAccessRights);
559
560 return 1;
561 }
562
563 /******************************************************************************
564 * GetSidIdentifierAuthority [ADVAPI32.@]
565 *
566 * PARAMS
567 * pSid []
568 */
569 PSID_IDENTIFIER_AUTHORITY WINAPI
570 GetSidIdentifierAuthority( PSID pSid )
571 {
572 return RtlIdentifierAuthoritySid(pSid);
573 }
574
575 /******************************************************************************
576 * GetSidSubAuthority [ADVAPI32.@]
577 *
578 * PARAMS
579 * pSid []
580 * nSubAuthority []
581 */
582 PDWORD WINAPI
583 GetSidSubAuthority( PSID pSid, DWORD nSubAuthority )
584 {
585 return RtlSubAuthoritySid(pSid, nSubAuthority);
586 }
587
588 /******************************************************************************
589 * GetSidSubAuthorityCount [ADVAPI32.@]
590 *
591 * PARAMS
592 * pSid []
593 */
594 PUCHAR WINAPI
595 GetSidSubAuthorityCount (PSID pSid)
596 {
597 return RtlSubAuthorityCountSid(pSid);
598 }
599
600 /******************************************************************************
601 * GetLengthSid [ADVAPI32.@]
602 *
603 * PARAMS
604 * pSid []
605 */
606 DWORD WINAPI
607 GetLengthSid (PSID pSid)
608 {
609 return RtlLengthSid(pSid);
610 }
611
612 /* ##############################################
613 ###### SECURITY DESCRIPTOR FUNCTIONS ######
614 ##############################################
615 */
616
617 /******************************************************************************
618 * BuildSecurityDescriptorA [ADVAPI32.@]
619 *
620 * Builds a SD from
621 *
622 * PARAMS
623 * pOwner [I]
624 * pGroup [I]
625 * cCountOfAccessEntries [I]
626 * pListOfAccessEntries [I]
627 * cCountOfAuditEntries [I]
628 * pListofAuditEntries [I]
629 * pOldSD [I]
630 * lpdwBufferLength [I/O]
631 * pNewSD [O]
632 */
633 DWORD WINAPI BuildSecurityDescriptorA(
634 IN PTRUSTEE_A pOwner,
635 IN PTRUSTEE_A pGroup,
636 IN DWORD cCountOfAccessEntries,
637 IN PEXPLICIT_ACCESS_A pListOfAccessEntries,
638 IN DWORD cCountOfAuditEntries,
639 IN PEXPLICIT_ACCESS_A pListofAuditEntries,
640 IN PSECURITY_DESCRIPTOR pOldSD,
641 IN OUT PDWORD lpdwBufferLength,
642 OUT PSECURITY_DESCRIPTOR pNewSD)
643 {
644 FIXME("(%p,%p,%ld,%p,%ld,%p,%p,%p,%p) stub!\n",pOwner,pGroup,
645 cCountOfAccessEntries,pListOfAccessEntries,cCountOfAuditEntries,
646 pListofAuditEntries,pOldSD,lpdwBufferLength,pNewSD);
647
648 return ERROR_CALL_NOT_IMPLEMENTED;
649 }
650
651 /******************************************************************************
652 * BuildSecurityDescriptorW [ADVAPI32.@]
653 *
654 * See BuildSecurityDescriptorA.
655 */
656 DWORD WINAPI BuildSecurityDescriptorW(
657 IN PTRUSTEE_W pOwner,
658 IN PTRUSTEE_W pGroup,
659 IN DWORD cCountOfAccessEntries,
660 IN PEXPLICIT_ACCESS_W pListOfAccessEntries,
661 IN DWORD cCountOfAuditEntries,
662 IN PEXPLICIT_ACCESS_W pListofAuditEntries,
663 IN PSECURITY_DESCRIPTOR pOldSD,
664 IN OUT PDWORD lpdwBufferLength,
665 OUT PSECURITY_DESCRIPTOR pNewSD)
666 {
667 FIXME("(%p,%p,%ld,%p,%ld,%p,%p,%p,%p) stub!\n",pOwner,pGroup,
668 cCountOfAccessEntries,pListOfAccessEntries,cCountOfAuditEntries,
669 pListofAuditEntries,pOldSD,lpdwBufferLength,pNewSD);
670
671 return ERROR_CALL_NOT_IMPLEMENTED;
672 }
673
674 /******************************************************************************
675 * InitializeSecurityDescriptor [ADVAPI32.@]
676 *
677 * PARAMS
678 * pDescr []
679 * revision []
680 */
681 BOOL WINAPI
682 InitializeSecurityDescriptor( PSECURITY_DESCRIPTOR pDescr, DWORD revision )
683 {
684 return set_ntstatus( RtlCreateSecurityDescriptor(pDescr, revision ));
685 }
686
687
688 /******************************************************************************
689 * MakeAbsoluteSD [ADVAPI32.@]
690 */
691 BOOL WINAPI MakeAbsoluteSD (
692 IN PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
693 OUT PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
694 OUT LPDWORD lpdwAbsoluteSecurityDescriptorSize,
695 OUT PACL pDacl,
696 OUT LPDWORD lpdwDaclSize,
697 OUT PACL pSacl,
698 OUT LPDWORD lpdwSaclSize,
699 OUT PSID pOwner,
700 OUT LPDWORD lpdwOwnerSize,
701 OUT PSID pPrimaryGroup,
702 OUT LPDWORD lpdwPrimaryGroupSize)
703 {
704 return set_ntstatus( RtlSelfRelativeToAbsoluteSD(pSelfRelativeSecurityDescriptor,
705 pAbsoluteSecurityDescriptor,
706 lpdwAbsoluteSecurityDescriptorSize,
707 pDacl, lpdwDaclSize, pSacl, lpdwSaclSize,
708 pOwner, lpdwOwnerSize,
709 pPrimaryGroup, lpdwPrimaryGroupSize));
710 }
711
712 /******************************************************************************
713 * GetKernelObjectSecurity [ADVAPI32.@]
714 */
715 BOOL WINAPI GetKernelObjectSecurity(
716 HANDLE Handle,
717 SECURITY_INFORMATION RequestedInformation,
718 PSECURITY_DESCRIPTOR pSecurityDescriptor,
719 DWORD nLength,
720 LPDWORD lpnLengthNeeded )
721 {
722 TRACE("(%p,0x%08lx,%p,0x%08lx,%p)\n", Handle, RequestedInformation,
723 pSecurityDescriptor, nLength, lpnLengthNeeded);
724
725 return set_ntstatus( NtQuerySecurityObject(Handle, RequestedInformation, pSecurityDescriptor,
726 nLength, lpnLengthNeeded ));
727 }
728
729 /******************************************************************************
730 * GetPrivateObjectSecurity [ADVAPI32.@]
731 */
732 BOOL WINAPI GetPrivateObjectSecurity(
733 PSECURITY_DESCRIPTOR ObjectDescriptor,
734 SECURITY_INFORMATION SecurityInformation,
735 PSECURITY_DESCRIPTOR ResultantDescriptor,
736 DWORD DescriptorLength,
737 PDWORD ReturnLength )
738 {
739 TRACE("(%p,0x%08lx,%p,0x%08lx,%p)\n", ObjectDescriptor, SecurityInformation,
740 ResultantDescriptor, DescriptorLength, ReturnLength);
741
742 return set_ntstatus( NtQuerySecurityObject(ObjectDescriptor, SecurityInformation,
743 ResultantDescriptor, DescriptorLength, ReturnLength ));
744 }
745
746 /******************************************************************************
747 * GetSecurityDescriptorLength [ADVAPI32.@]
748 */
749 DWORD WINAPI GetSecurityDescriptorLength( PSECURITY_DESCRIPTOR pDescr)
750 {
751 return RtlLengthSecurityDescriptor(pDescr);
752 }
753
754 /******************************************************************************
755 * GetSecurityDescriptorOwner [ADVAPI32.@]
756 *
757 * PARAMS
758 * pOwner []
759 * lpbOwnerDefaulted []
760 */
761 BOOL WINAPI
762 GetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pDescr, PSID *pOwner,
763 LPBOOL lpbOwnerDefaulted )
764 {
765 BOOLEAN defaulted;
766 BOOL ret = set_ntstatus( RtlGetOwnerSecurityDescriptor( pDescr, pOwner, &defaulted ));
767 *lpbOwnerDefaulted = defaulted;
768 return ret;
769 }
770
771 /******************************************************************************
772 * SetSecurityDescriptorOwner [ADVAPI32.@]
773 *
774 * PARAMS
775 */
776 BOOL WINAPI SetSecurityDescriptorOwner( PSECURITY_DESCRIPTOR pSecurityDescriptor,
777 PSID pOwner, BOOL bOwnerDefaulted)
778 {
779 return set_ntstatus( RtlSetOwnerSecurityDescriptor(pSecurityDescriptor, pOwner, bOwnerDefaulted));
780 }
781 /******************************************************************************
782 * GetSecurityDescriptorGroup [ADVAPI32.@]
783 */
784 BOOL WINAPI GetSecurityDescriptorGroup(
785 PSECURITY_DESCRIPTOR SecurityDescriptor,
786 PSID *Group,
787 LPBOOL GroupDefaulted)
788 {
789 BOOLEAN defaulted;
790 BOOL ret = set_ntstatus( RtlGetGroupSecurityDescriptor(SecurityDescriptor, Group, &defaulted ));
791 *GroupDefaulted = defaulted;
792 return ret;
793 }
794 /******************************************************************************
795 * SetSecurityDescriptorGroup [ADVAPI32.@]
796 */
797 BOOL WINAPI SetSecurityDescriptorGroup ( PSECURITY_DESCRIPTOR SecurityDescriptor,
798 PSID Group, BOOL GroupDefaulted)
799 {
800 return set_ntstatus( RtlSetGroupSecurityDescriptor( SecurityDescriptor, Group, GroupDefaulted));
801 }
802
803 /******************************************************************************
804 * IsValidSecurityDescriptor [ADVAPI32.@]
805 *
806 * PARAMS
807 * lpsecdesc []
808 */
809 BOOL WINAPI
810 IsValidSecurityDescriptor( PSECURITY_DESCRIPTOR SecurityDescriptor )
811 {
812 return set_ntstatus( RtlValidSecurityDescriptor(SecurityDescriptor));
813 }
814
815 /******************************************************************************
816 * GetSecurityDescriptorDacl [ADVAPI32.@]
817 */
818 BOOL WINAPI GetSecurityDescriptorDacl(
819 IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
820 OUT LPBOOL lpbDaclPresent,
821 OUT PACL *pDacl,
822 OUT LPBOOL lpbDaclDefaulted)
823 {
824 BOOLEAN present, defaulted;
825 BOOL ret = set_ntstatus( RtlGetDaclSecurityDescriptor(pSecurityDescriptor, &present, pDacl, &defaulted));
826 *lpbDaclPresent = present;
827 *lpbDaclDefaulted = defaulted;
828 return ret;
829 }
830
831 /******************************************************************************
832 * SetSecurityDescriptorDacl [ADVAPI32.@]
833 */
834 BOOL WINAPI
835 SetSecurityDescriptorDacl (
836 PSECURITY_DESCRIPTOR lpsd,
837 BOOL daclpresent,
838 PACL dacl,
839 BOOL dacldefaulted )
840 {
841 return set_ntstatus( RtlSetDaclSecurityDescriptor (lpsd, daclpresent, dacl, dacldefaulted ) );
842 }
843 /******************************************************************************
844 * GetSecurityDescriptorSacl [ADVAPI32.@]
845 */
846 BOOL WINAPI GetSecurityDescriptorSacl(
847 IN PSECURITY_DESCRIPTOR lpsd,
848 OUT LPBOOL lpbSaclPresent,
849 OUT PACL *pSacl,
850 OUT LPBOOL lpbSaclDefaulted)
851 {
852 BOOLEAN present, defaulted;
853 BOOL ret = set_ntstatus( RtlGetSaclSecurityDescriptor(lpsd, &present, pSacl, &defaulted) );
854 *lpbSaclPresent = present;
855 *lpbSaclDefaulted = defaulted;
856 return ret;
857 }
858
859 /**************************************************************************
860 * SetSecurityDescriptorSacl [ADVAPI32.@]
861 */
862 BOOL WINAPI SetSecurityDescriptorSacl (
863 PSECURITY_DESCRIPTOR lpsd,
864 BOOL saclpresent,
865 PACL lpsacl,
866 BOOL sacldefaulted)
867 {
868 return set_ntstatus (RtlSetSaclSecurityDescriptor(lpsd, saclpresent, lpsacl, sacldefaulted));
869 }
870 /******************************************************************************
871 * MakeSelfRelativeSD [ADVAPI32.@]
872 *
873 * PARAMS
874 * lpabssecdesc []
875 * lpselfsecdesc []
876 * lpbuflen []
877 */
878 BOOL WINAPI
879 MakeSelfRelativeSD(
880 IN PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
881 IN PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
882 IN OUT LPDWORD lpdwBufferLength)
883 {
884 return set_ntstatus( RtlMakeSelfRelativeSD( pAbsoluteSecurityDescriptor,
885 pSelfRelativeSecurityDescriptor, lpdwBufferLength));
886 }
887
888 /******************************************************************************
889 * GetSecurityDescriptorControl [ADVAPI32.@]
890 */
891
892 BOOL WINAPI GetSecurityDescriptorControl ( PSECURITY_DESCRIPTOR pSecurityDescriptor,
893 PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision)
894 {
895 return set_ntstatus( RtlGetControlSecurityDescriptor(pSecurityDescriptor,pControl,lpdwRevision));
896 }
897
898 /* ##############################
899 ###### ACL FUNCTIONS ######
900 ##############################
901 */
902
903 /*************************************************************************
904 * InitializeAcl [ADVAPI32.@]
905 */
906 BOOL WINAPI InitializeAcl(PACL acl, DWORD size, DWORD rev)
907 {
908 return set_ntstatus( RtlCreateAcl(acl, size, rev));
909 }
910
911 BOOL WINAPI ImpersonateNamedPipeClient( HANDLE hNamedPipe )
912 {
913 TRACE("(%p)\n", hNamedPipe);
914
915 return set_ntstatus( NtFsControlFile(hNamedPipe, NULL, NULL, NULL, NULL,
916 FSCTL_PIPE_IMPERSONATE, NULL, 0, NULL, 0) );
917 }
918
919 /******************************************************************************
920 * AddAccessAllowedAce [ADVAPI32.@]
921 */
922 BOOL WINAPI AddAccessAllowedAce(
923 IN OUT PACL pAcl,
924 IN DWORD dwAceRevision,
925 IN DWORD AccessMask,
926 IN PSID pSid)
927 {
928 return set_ntstatus(RtlAddAccessAllowedAce(pAcl, dwAceRevision, AccessMask, pSid));
929 }
930
931 /******************************************************************************
932 * AddAccessAllowedAceEx [ADVAPI32.@]
933 */
934 BOOL WINAPI AddAccessAllowedAceEx(
935 IN OUT PACL pAcl,
936 IN DWORD dwAceRevision,
937 IN DWORD AceFlags,
938 IN DWORD AccessMask,
939 IN PSID pSid)
940 {
941 return set_ntstatus(RtlAddAccessAllowedAceEx(pAcl, dwAceRevision, AceFlags, AccessMask, pSid));
942 }
943
944 /******************************************************************************
945 * AddAccessDeniedAce [ADVAPI32.@]
946 */
947 BOOL WINAPI AddAccessDeniedAce(
948 IN OUT PACL pAcl,
949 IN DWORD dwAceRevision,
950 IN DWORD AccessMask,
951 IN PSID pSid)
952 {
953 return set_ntstatus(RtlAddAccessDeniedAce(pAcl, dwAceRevision, AccessMask, pSid));
954 }
955
956 /******************************************************************************
957 * AddAccessDeniedAceEx [ADVAPI32.@]
958 */
959 BOOL WINAPI AddAccessDeniedAceEx(
960 IN OUT PACL pAcl,
961 IN DWORD dwAceRevision,
962 IN DWORD AceFlags,
963 IN DWORD AccessMask,
964 IN PSID pSid)
965 {
966 return set_ntstatus(RtlAddAccessDeniedAceEx(pAcl, dwAceRevision, AceFlags, AccessMask, pSid));
967 }
968
969 /******************************************************************************
970 * AddAce [ADVAPI32.@]
971 */
972 BOOL WINAPI AddAce(
973 IN OUT PACL pAcl,
974 IN DWORD dwAceRevision,
975 IN DWORD dwStartingAceIndex,
976 LPVOID pAceList,
977 DWORD nAceListLength)
978 {
979 return set_ntstatus(RtlAddAce(pAcl, dwAceRevision, dwStartingAceIndex, pAceList, nAceListLength));
980 }
981
982 /******************************************************************************
983 * DeleteAce [ADVAPI32.@]
984 */
985 BOOL WINAPI DeleteAce(PACL pAcl, DWORD dwAceIndex)
986 {
987 return set_ntstatus(RtlDeleteAce(pAcl, dwAceIndex));
988 }
989
990 /******************************************************************************
991 * FindFirstFreeAce [ADVAPI32.@]
992 */
993 BOOL WINAPI FindFirstFreeAce(IN PACL pAcl, LPVOID * pAce)
994 {
995 return RtlFirstFreeAce(pAcl, (PACE_HEADER *)pAce);
996 }
997
998 /******************************************************************************
999 * GetAce [ADVAPI32.@]
1000 */
1001 BOOL WINAPI GetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce )
1002 {
1003 return set_ntstatus(RtlGetAce(pAcl, dwAceIndex, pAce));
1004 }
1005
1006 /******************************************************************************
1007 * GetAclInformation [ADVAPI32.@]
1008 */
1009 BOOL WINAPI GetAclInformation(
1010 PACL pAcl,
1011 LPVOID pAclInformation,
1012 DWORD nAclInformationLength,
1013 ACL_INFORMATION_CLASS dwAclInformationClass)
1014 {
1015 return set_ntstatus(RtlQueryInformationAcl(pAcl, pAclInformation,
1016 nAclInformationLength, dwAclInformationClass));
1017 }
1018
1019 /******************************************************************************
1020 * IsValidAcl [ADVAPI32.@]
1021 */
1022 BOOL WINAPI IsValidAcl(IN PACL pAcl)
1023 {
1024 return RtlValidAcl(pAcl);
1025 }
1026
1027 /* ##############################
1028 ###### MISC FUNCTIONS ######
1029 ##############################
1030 */
1031
1032 /******************************************************************************
1033 * AllocateLocallyUniqueId [ADVAPI32.@]
1034 *
1035 * PARAMS
1036 * lpLuid []
1037 */
1038 BOOL WINAPI AllocateLocallyUniqueId( PLUID lpLuid )
1039 {
1040 return set_ntstatus(NtAllocateLocallyUniqueId(lpLuid));
1041 }
1042
1043 static const WCHAR SE_CREATE_TOKEN_NAME_W[] =
1044 { 'S','e','C','r','e','a','t','e','T','o','k','e','n','P','r','i','v','i','l','e','g','e',0 };
1045 static const WCHAR SE_ASSIGNPRIMARYTOKEN_NAME_W[] =
1046 { 'S','e','A','s','s','i','g','n','P','r','i','m','a','r','y','T','o','k','e','n','P','r','i','v','i','l','e','g','e',0 };
1047 static const WCHAR SE_LOCK_MEMORY_NAME_W[] =
1048 { 'S','e','L','o','c','k','M','e','m','o','r','y','P','r','i','v','i','l','e','g','e',0 };
1049 static const WCHAR SE_INCREASE_QUOTA_NAME_W[] =
1050 { 'S','e','I','n','c','r','e','a','s','e','Q','u','o','t','a','P','r','i','v','i','l','e','g','e',0 };
1051 static const WCHAR SE_MACHINE_ACCOUNT_NAME_W[] =
1052 { 'S','e','M','a','c','h','i','n','e','A','c','c','o','u','n','t','P','r','i','v','i','l','e','g','e',0 };
1053 static const WCHAR SE_TCB_NAME_W[] =
1054 { 'S','e','T','c','b','P','r','i','v','i','l','e','g','e',0 };
1055 static const WCHAR SE_SECURITY_NAME_W[] =
1056 { 'S','e','S','e','c','u','r','i','t','y','P','r','i','v','i','l','e','g','e',0 };
1057 static const WCHAR SE_TAKE_OWNERSHIP_NAME_W[] =
1058 { 'S','e','T','a','k','e','O','w','n','e','r','s','h','i','p','P','r','i','v','i','l','e','g','e',0 };
1059 static const WCHAR SE_LOAD_DRIVER_NAME_W[] =
1060 { 'S','e','L','o','a','d','D','r','i','v','e','r','P','r','i','v','i','l','e','g','e',0 };
1061 static const WCHAR SE_SYSTEM_PROFILE_NAME_W[] =
1062 { 'S','e','S','y','s','t','e','m','P','r','o','f','i','l','e','P','r','i','v','i','l','e','g','e',0 };
1063 static const WCHAR SE_SYSTEMTIME_NAME_W[] =
1064 { 'S','e','S','y','s','t','e','m','t','i','m','e','P','r','i','v','i','l','e','g','e',0 };
1065 static const WCHAR SE_PROF_SINGLE_PROCESS_NAME_W[] =
1066 { 'S','e','P','r','o','f','i','l','e','S','i','n','g','l','e','P','r','o','c','e','s','s','P','r','i','v','i','l','e','g','e',0 };
1067 static const WCHAR SE_INC_BASE_PRIORITY_NAME_W[] =
1068 { 'S','e','I','n','c','r','e','a','s','e','B','a','s','e','P','r','i','o','r','i','t','y','P','r','i','v','i','l','e','g','e',0 };
1069 static const WCHAR SE_CREATE_PAGEFILE_NAME_W[] =
1070 { 'S','e','C','r','e','a','t','e','P','a','g','e','f','i','l','e','P','r','i','v','i','l','e','g','e',0 };
1071 static const WCHAR SE_CREATE_PERMANENT_NAME_W[] =
1072 { 'S','e','C','r','e','a','t','e','P','e','r','m','a','n','e','n','t','P','r','i','v','i','l','e','g','e',0 };
1073 static const WCHAR SE_BACKUP_NAME_W[] =
1074 { 'S','e','B','a','c','k','u','p','P','r','i','v','i','l','e','g','e',0 };
1075 static const WCHAR SE_RESTORE_NAME_W[] =
1076 { 'S','e','R','e','s','t','o','r','e','P','r','i','v','i','l','e','g','e',0 };
1077 static const WCHAR SE_SHUTDOWN_NAME_W[] =
1078 { 'S','e','S','h','u','t','d','o','w','n','P','r','i','v','i','l','e','g','e',0 };
1079 static const WCHAR SE_DEBUG_NAME_W[] =
1080 { 'S','e','D','e','b','u','g','P','r','i','v','i','l','e','g','e',0 };
1081 static const WCHAR SE_AUDIT_NAME_W[] =
1082 { 'S','e','A','u','d','i','t','P','r','i','v','i','l','e','g','e',0 };
1083 static const WCHAR SE_SYSTEM_ENVIRONMENT_NAME_W[] =
1084 { 'S','e','S','y','s','t','e','m','E','n','v','i','r','o','n','m','e','n','t','P','r','i','v','i','l','e','g','e',0 };
1085 static const WCHAR SE_CHANGE_NOTIFY_NAME_W[] =
1086 { 'S','e','C','h','a','n','g','e','N','o','t','i','f','y','P','r','i','v','i','l','e','g','e',0 };
1087 static const WCHAR SE_REMOTE_SHUTDOWN_NAME_W[] =
1088 { 'S','e','R','e','m','o','t','e','S','h','u','t','d','o','w','n','P','r','i','v','i','l','e','g','e',0 };
1089 static const WCHAR SE_UNDOCK_NAME_W[] =
1090 { 'S','e','U','n','d','o','c','k','P','r','i','v','i','l','e','g','e',0 };
1091 static const WCHAR SE_SYNC_AGENT_NAME_W[] =
1092 { 'S','e','S','y','n','c','A','g','e','n','t','P','r','i','v','i','l','e','g','e',0 };
1093 static const WCHAR SE_ENABLE_DELEGATION_NAME_W[] =
1094 { 'S','e','E','n','a','b','l','e','D','e','l','e','g','a','t','i','o','n','P','r','i','v','i','l','e','g','e',0 };
1095 static const WCHAR SE_MANAGE_VOLUME_NAME_W[] =
1096 { 'S','e','M','a','n','a','g','e','V','o','l','u','m','e','P','r','i','v','i','l','e','g','e',0 };
1097 static const WCHAR SE_IMPERSONATE_NAME_W[] =
1098 { 'S','e','I','m','p','e','r','s','o','n','a','t','e','P','r','i','v','i','l','e','g','e',0 };
1099 static const WCHAR SE_CREATE_GLOBAL_NAME_W[] =
1100 { 'S','e','C','r','e','a','t','e','G','l','o','b','a','l','P','r','i','v','i','l','e','g','e',0 };
1101
1102 static const WCHAR * const WellKnownPrivNames[SE_MAX_WELL_KNOWN_PRIVILEGE + 1] =
1103 {
1104 NULL,
1105 NULL,
1106 SE_CREATE_TOKEN_NAME_W,
1107 SE_ASSIGNPRIMARYTOKEN_NAME_W,
1108 SE_LOCK_MEMORY_NAME_W,
1109 SE_INCREASE_QUOTA_NAME_W,
1110 SE_MACHINE_ACCOUNT_NAME_W,
1111 SE_TCB_NAME_W,
1112 SE_SECURITY_NAME_W,
1113 SE_TAKE_OWNERSHIP_NAME_W,
1114 SE_LOAD_DRIVER_NAME_W,
1115 SE_SYSTEM_PROFILE_NAME_W,
1116 SE_SYSTEMTIME_NAME_W,
1117 SE_PROF_SINGLE_PROCESS_NAME_W,
1118 SE_INC_BASE_PRIORITY_NAME_W,
1119 SE_CREATE_PAGEFILE_NAME_W,
1120 SE_CREATE_PERMANENT_NAME_W,
1121 SE_BACKUP_NAME_W,
1122 SE_RESTORE_NAME_W,
1123 SE_SHUTDOWN_NAME_W,
1124 SE_DEBUG_NAME_W,
1125 SE_AUDIT_NAME_W,
1126 SE_SYSTEM_ENVIRONMENT_NAME_W,
1127 SE_CHANGE_NOTIFY_NAME_W,
1128 SE_REMOTE_SHUTDOWN_NAME_W,
1129 SE_UNDOCK_NAME_W,
1130 SE_SYNC_AGENT_NAME_W,
1131 SE_ENABLE_DELEGATION_NAME_W,
1132 SE_MANAGE_VOLUME_NAME_W,
1133 SE_IMPERSONATE_NAME_W,
1134 SE_CREATE_GLOBAL_NAME_W,
1135 };
1136
1137 /******************************************************************************
1138 * LookupPrivilegeValueW [ADVAPI32.@]
1139 *
1140 * See LookupPrivilegeValueA.
1141 */
1142 BOOL WINAPI
1143 LookupPrivilegeValueW( LPCWSTR lpSystemName, LPCWSTR lpName, PLUID lpLuid )
1144 {
1145 UINT i;
1146
1147 TRACE("%s,%s,%p\n",debugstr_w(lpSystemName), debugstr_w(lpName), lpLuid);
1148
1149 if (!ADVAPI_IsLocalComputer(lpSystemName))
1150 {
1151 SetLastError(RPC_S_SERVER_UNAVAILABLE);
1152 return FALSE;
1153 }
1154 if (!lpName)
1155 {
1156 SetLastError(ERROR_NO_SUCH_PRIVILEGE);
1157 return FALSE;
1158 }
1159 for( i=SE_MIN_WELL_KNOWN_PRIVILEGE; i<SE_MAX_WELL_KNOWN_PRIVILEGE; i++ )
1160 {
1161 if( !WellKnownPrivNames[i] )
1162 continue;
1163 if( strcmpiW( WellKnownPrivNames[i], lpName) )
1164 continue;
1165 lpLuid->LowPart = i;
1166 lpLuid->HighPart = 0;
1167 TRACE( "%s -> %08lx-%08lx\n",debugstr_w( lpSystemName ),
1168 lpLuid->HighPart, lpLuid->LowPart );
1169 return TRUE;
1170 }
1171 SetLastError(ERROR_NO_SUCH_PRIVILEGE);
1172 return FALSE;
1173 }
1174
1175 /******************************************************************************
1176 * LookupPrivilegeValueA [ADVAPI32.@]
1177 *
1178 * Retrieves LUID used on a system to represent the privilege name.
1179 *
1180 * PARAMS
1181 * lpSystemName [I] Name of the system
1182 * lpName [I] Name of the privilege
1183 * lpLuid [O] Destination for the resulting LUID
1184 *
1185 * RETURNS
1186 * Success: TRUE. lpLuid contains the requested LUID.
1187 * Failure: FALSE.
1188 */
1189 BOOL WINAPI
1190 LookupPrivilegeValueA( LPCSTR lpSystemName, LPCSTR lpName, PLUID lpLuid )
1191 {
1192 UNICODE_STRING lpSystemNameW;
1193 UNICODE_STRING lpNameW;
1194 BOOL ret;
1195
1196 RtlCreateUnicodeStringFromAsciiz(&lpSystemNameW, lpSystemName);
1197 RtlCreateUnicodeStringFromAsciiz(&lpNameW,lpName);
1198 ret = LookupPrivilegeValueW(lpSystemNameW.Buffer, lpNameW.Buffer, lpLuid);
1199 RtlFreeUnicodeString(&lpNameW);
1200 RtlFreeUnicodeString(&lpSystemNameW);
1201 return ret;
1202 }
1203
1204 BOOL WINAPI LookupPrivilegeDisplayNameA( LPCSTR lpSystemName, LPCSTR lpName, LPSTR lpDisplayName,
1205 LPDWORD cchDisplayName, LPDWORD lpLanguageId )
1206 {
1207 FIXME("%s %s %s %p %p - stub\n", debugstr_a(lpSystemName), debugstr_a(lpName),
1208 debugstr_a(lpDisplayName), cchDisplayName, lpLanguageId);
1209
1210 return FALSE;
1211 }
1212
1213 BOOL WINAPI LookupPrivilegeDisplayNameW( LPCWSTR lpSystemName, LPCWSTR lpName, LPWSTR lpDisplayName,
1214 LPDWORD cchDisplayName, LPDWORD lpLanguageId )
1215 {
1216 FIXME("%s %s %s %p %p - stub\n", debugstr_w(lpSystemName), debugstr_w(lpName),
1217 debugstr_w(lpDisplayName), cchDisplayName, lpLanguageId);
1218
1219 return FALSE;
1220 }
1221
1222 /******************************************************************************
1223 * LookupPrivilegeNameA [ADVAPI32.@]
1224 *
1225 * See LookupPrivilegeNameW
1226 */
1227 BOOL WINAPI
1228 LookupPrivilegeNameA( LPCSTR lpSystemName, PLUID lpLuid, LPSTR lpName,
1229 LPDWORD cchName)
1230 {
1231 UNICODE_STRING lpSystemNameW;
1232 BOOL ret;
1233 DWORD wLen = 0;
1234
1235 TRACE("%s %p %p %p\n", debugstr_a(lpSystemName), lpLuid, lpName, cchName);
1236
1237 RtlCreateUnicodeStringFromAsciiz(&lpSystemNameW, lpSystemName);
1238 ret = LookupPrivilegeNameW(lpSystemNameW.Buffer, lpLuid, NULL, &wLen);
1239 if (!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
1240 {
1241 LPWSTR lpNameW = HeapAlloc(GetProcessHeap(), 0, wLen * sizeof(WCHAR));
1242
1243 ret = LookupPrivilegeNameW(lpSystemNameW.Buffer, lpLuid, lpNameW,
1244 &wLen);
1245 if (ret)
1246 {
1247 /* Windows crashes if cchName is NULL, so will I */
1248 int len = WideCharToMultiByte(CP_ACP, 0, lpNameW, -1, lpName,
1249 *cchName, NULL, NULL);
1250
1251 if (len == 0)
1252 {
1253 /* WideCharToMultiByte failed */
1254 ret = FALSE;
1255 }
1256 else if (len > *cchName)
1257 {
1258 *cchName = len;
1259 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1260 ret = FALSE;
1261 }
1262 else
1263 {
1264 /* WideCharToMultiByte succeeded, output length needs to be
1265 * length not including NULL terminator
1266 */
1267 *cchName = len - 1;
1268 }
1269 }
1270 HeapFree(GetProcessHeap(), 0, lpNameW);
1271 }
1272 RtlFreeUnicodeString(&lpSystemNameW);
1273 return ret;
1274 }
1275
1276 /******************************************************************************
1277 * LookupPrivilegeNameW [ADVAPI32.@]
1278 *
1279 * Retrieves the privilege name referred to by the LUID lpLuid.
1280 *
1281 * PARAMS
1282 * lpSystemName [I] Name of the system
1283 * lpLuid [I] Privilege value
1284 * lpName [O] Name of the privilege
1285 * cchName [I/O] Number of characters in lpName.
1286 *
1287 * RETURNS
1288 * Success: TRUE. lpName contains the name of the privilege whose value is
1289 * *lpLuid.
1290 * Failure: FALSE.
1291 *
1292 * REMARKS
1293 * Only well-known privilege names (those defined in winnt.h) can be retrieved
1294 * using this function.
1295 * If the length of lpName is too small, on return *cchName will contain the
1296 * number of WCHARs needed to contain the privilege, including the NULL
1297 * terminator, and GetLastError will return ERROR_INSUFFICIENT_BUFFER.
1298 * On success, *cchName will contain the number of characters stored in
1299 * lpName, NOT including the NULL terminator.
1300 */
1301 BOOL WINAPI
1302 LookupPrivilegeNameW( LPCWSTR lpSystemName, PLUID lpLuid, LPWSTR lpName,
1303 LPDWORD cchName)
1304 {
1305 size_t privNameLen;
1306
1307 TRACE("%s,%p,%p,%p\n",debugstr_w(lpSystemName), lpLuid, lpName, cchName);
1308
1309 if (!ADVAPI_IsLocalComputer(lpSystemName))
1310 {
1311 SetLastError(RPC_S_SERVER_UNAVAILABLE);
1312 return FALSE;
1313 }
1314 if (lpLuid->HighPart || (lpLuid->LowPart < SE_MIN_WELL_KNOWN_PRIVILEGE ||
1315 lpLuid->LowPart > SE_MAX_WELL_KNOWN_PRIVILEGE))
1316 {
1317 SetLastError(ERROR_NO_SUCH_PRIVILEGE);
1318 return FALSE;
1319 }
1320 privNameLen = strlenW(WellKnownPrivNames[lpLuid->LowPart]);
1321 /* Windows crashes if cchName is NULL, so will I */
1322 if (*cchName <= privNameLen)
1323 {
1324 *cchName = privNameLen + 1;
1325 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1326 return FALSE;
1327 }
1328 else
1329 {
1330 strcpyW(lpName, WellKnownPrivNames[lpLuid->LowPart]);
1331 *cchName = privNameLen;
1332 return TRUE;
1333 }
1334 }
1335
1336 /******************************************************************************
1337 * GetFileSecurityA [ADVAPI32.@]
1338 *
1339 * Obtains Specified information about the security of a file or directory.
1340 *
1341 * PARAMS
1342 * lpFileName [I] Name of the file to get info for
1343 * RequestedInformation [I] SE_ flags from "winnt.h"
1344 * pSecurityDescriptor [O] Destination for security information
1345 * nLength [I] Length of pSecurityDescriptor
1346 * lpnLengthNeeded [O] Destination for length of returned security information
1347 *
1348 * RETURNS
1349 * Success: TRUE. pSecurityDescriptor contains the requested information.
1350 * Failure: FALSE. lpnLengthNeeded contains the required space to return the info.
1351 *
1352 * NOTES
1353 * The information returned is constrained by the callers access rights and
1354 * privileges.
1355 */
1356 BOOL WINAPI
1357 GetFileSecurityA( LPCSTR lpFileName,
1358 SECURITY_INFORMATION RequestedInformation,
1359 PSECURITY_DESCRIPTOR pSecurityDescriptor,
1360 DWORD nLength, LPDWORD lpnLengthNeeded )
1361 {
1362 DWORD len;
1363 BOOL r;
1364 LPWSTR name = NULL;
1365
1366 if( lpFileName )
1367 {
1368 len = MultiByteToWideChar( CP_ACP, 0, lpFileName, -1, NULL, 0 );
1369 name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1370 MultiByteToWideChar( CP_ACP, 0, lpFileName, -1, name, len );
1371 }
1372
1373 r = GetFileSecurityW( name, RequestedInformation, pSecurityDescriptor,
1374 nLength, lpnLengthNeeded );
1375 HeapFree( GetProcessHeap(), 0, name );
1376
1377 return r;
1378 }
1379
1380 /******************************************************************************
1381 * GetFileSecurityW [ADVAPI32.@]
1382 *
1383 * See GetFileSecurityA.
1384 */
1385 BOOL WINAPI
1386 GetFileSecurityW( LPCWSTR lpFileName,
1387 SECURITY_INFORMATION RequestedInformation,
1388 PSECURITY_DESCRIPTOR pSecurityDescriptor,
1389 DWORD nLength, LPDWORD lpnLengthNeeded )
1390 {
1391 DWORD nNeeded;
1392 LPBYTE pBuffer;
1393 DWORD iLocNow;
1394 SECURITY_DESCRIPTOR_RELATIVE *pSDRelative;
1395
1396 if(INVALID_FILE_ATTRIBUTES == GetFileAttributesW(lpFileName))
1397 return FALSE;
1398
1399 FIXME("(%s) : returns fake SECURITY_DESCRIPTOR\n", debugstr_w(lpFileName) );
1400
1401 nNeeded = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
1402 if (RequestedInformation & OWNER_SECURITY_INFORMATION)
1403 nNeeded += sizeof(sidWorld);
1404 if (RequestedInformation & GROUP_SECURITY_INFORMATION)
1405 nNeeded += sizeof(sidWorld);
1406 if (RequestedInformation & DACL_SECURITY_INFORMATION)
1407 nNeeded += WINE_SIZE_OF_WORLD_ACCESS_ACL;
1408 if (RequestedInformation & SACL_SECURITY_INFORMATION)
1409 nNeeded += WINE_SIZE_OF_WORLD_ACCESS_ACL;
1410
1411 *lpnLengthNeeded = nNeeded;
1412
1413 if (nNeeded > nLength)
1414 return TRUE;
1415
1416 if (!InitializeSecurityDescriptor(pSecurityDescriptor, SECURITY_DESCRIPTOR_REVISION))
1417 return FALSE;
1418
1419 pSDRelative = (PISECURITY_DESCRIPTOR_RELATIVE) pSecurityDescriptor;
1420 pSDRelative->Control |= SE_SELF_RELATIVE;
1421 pBuffer = (LPBYTE) pSDRelative;
1422 iLocNow = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
1423
1424 if (RequestedInformation & OWNER_SECURITY_INFORMATION)
1425 {
1426 memcpy(pBuffer + iLocNow, &sidWorld, sizeof(sidWorld));
1427 pSDRelative->Owner = iLocNow;
1428 iLocNow += sizeof(sidWorld);
1429 }
1430 if (RequestedInformation & GROUP_SECURITY_INFORMATION)
1431 {
1432 memcpy(pBuffer + iLocNow, &sidWorld, sizeof(sidWorld));
1433 pSDRelative->Group = iLocNow;
1434 iLocNow += sizeof(sidWorld);
1435 }
1436 if (RequestedInformation & DACL_SECURITY_INFORMATION)
1437 {
1438 GetWorldAccessACL((PACL) (pBuffer + iLocNow));
1439 pSDRelative->Dacl = iLocNow;
1440 iLocNow += WINE_SIZE_OF_WORLD_ACCESS_ACL;
1441 }
1442 if (RequestedInformation & SACL_SECURITY_INFORMATION)
1443 {
1444 GetWorldAccessACL((PACL) (pBuffer + iLocNow));
1445 pSDRelative->Sacl = iLocNow;
1446 /* iLocNow += WINE_SIZE_OF_WORLD_ACCESS_ACL; */
1447 }
1448 return TRUE;
1449 }
1450
1451
1452 /******************************************************************************
1453 * LookupAccountSidA [ADVAPI32.@]
1454 */
1455 BOOL WINAPI
1456 LookupAccountSidA(
1457 IN LPCSTR system,
1458 IN PSID sid,
1459 OUT LPSTR account,
1460 IN OUT LPDWORD accountSize,
1461 OUT LPSTR domain,
1462 IN OUT LPDWORD domainSize,
1463 OUT PSID_NAME_USE name_use )
1464 {
1465 static const char ac[] = "Administrator";
1466 static const char dm[] = "DOMAIN";
1467 FIXME("(%s,sid=%p,%p,%p(%lu),%p,%p(%lu),%p): semi-stub\n",
1468 debugstr_a(system),sid,
1469 account,accountSize,accountSize?*accountSize:0,
1470 domain,domainSize,domainSize?*domainSize:0,
1471 name_use);
1472
1473 if (accountSize) *accountSize = strlen(ac)+1;
1474 if (account && (*accountSize > strlen(ac)))
1475 strcpy(account, ac);
1476
1477 if (domainSize) *domainSize = strlen(dm)+1;
1478 if (domain && (*domainSize > strlen(dm)))
1479 strcpy(domain,dm);
1480
1481 if (name_use) *name_use = SidTypeUser;
1482 return TRUE;
1483 }
1484
1485 /******************************************************************************
1486 * LookupAccountSidW [ADVAPI32.@]
1487 *
1488 * PARAMS
1489 * system []
1490 * sid []
1491 * account []
1492 * accountSize []
1493 * domain []
1494 * domainSize []
1495 * name_use []
1496 */
1497 BOOL WINAPI
1498 LookupAccountSidW(
1499 IN LPCWSTR system,
1500 IN PSID sid,
1501 OUT LPWSTR account,
1502 IN OUT LPDWORD accountSize,
1503 OUT LPWSTR domain,
1504 IN OUT LPDWORD domainSize,
1505 OUT PSID_NAME_USE name_use )
1506 {
1507 static const WCHAR ac[] = {'A','d','m','i','n','i','s','t','r','a','t','o','r',0};
1508 static const WCHAR dm[] = {'D','O','M','A','I','N',0};
1509 FIXME("(%s,sid=%p,%p,%p(%lu),%p,%p(%lu),%p): semi-stub\n",
1510 debugstr_w(system),sid,
1511 account,accountSize,accountSize?*accountSize:0,
1512 domain,domainSize,domainSize?*domainSize:0,
1513 name_use);
1514
1515 if (accountSize) *accountSize = strlenW(ac)+1;
1516 if (account && (*accountSize > strlenW(ac)))
1517 strcpyW(account, ac);
1518
1519 if (domainSize) *domainSize = strlenW(dm)+1;
1520 if (domain && (*domainSize > strlenW(dm)))
1521 strcpyW(domain,dm);
1522
1523 if (name_use) *name_use = SidTypeUser;
1524 return TRUE;
1525 }
1526
1527 /******************************************************************************
1528 * SetFileSecurityA [ADVAPI32.@]
1529 * Sets the security of a file or directory
1530 */
1531 BOOL WINAPI SetFileSecurityA( LPCSTR lpFileName,
1532 SECURITY_INFORMATION RequestedInformation,
1533 PSECURITY_DESCRIPTOR pSecurityDescriptor)
1534 {
1535 DWORD len;
1536 BOOL r;
1537 LPWSTR name = NULL;
1538
1539 if( lpFileName )
1540 {
1541 len = MultiByteToWideChar( CP_ACP, 0, lpFileName, -1, NULL, 0 );
1542 name = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR) );
1543 MultiByteToWideChar( CP_ACP, 0, lpFileName, -1, name, len );
1544 }
1545
1546 r = SetFileSecurityW( name, RequestedInformation, pSecurityDescriptor );
1547 HeapFree( GetProcessHeap(), 0, name );
1548
1549 return r;
1550 }
1551
1552 /******************************************************************************
1553 * SetFileSecurityW [ADVAPI32.@]
1554 * Sets the security of a file or directory
1555 *
1556 * PARAMS
1557 * lpFileName []
1558 * RequestedInformation []
1559 * pSecurityDescriptor []
1560 */
1561 BOOL WINAPI
1562 SetFileSecurityW( LPCWSTR lpFileName,
1563 SECURITY_INFORMATION RequestedInformation,
1564 PSECURITY_DESCRIPTOR pSecurityDescriptor )
1565 {
1566 FIXME("(%s) : stub\n", debugstr_w(lpFileName) );
1567 return TRUE;
1568 }
1569
1570 /******************************************************************************
1571 * QueryWindows31FilesMigration [ADVAPI32.@]
1572 *
1573 * PARAMS
1574 * x1 []
1575 */
1576 BOOL WINAPI
1577 QueryWindows31FilesMigration( DWORD x1 )
1578 {
1579 FIXME("(%ld):stub\n",x1);
1580 return TRUE;
1581 }
1582
1583 /******************************************************************************
1584 * SynchronizeWindows31FilesAndWindowsNTRegistry [ADVAPI32.@]
1585 *
1586 * PARAMS
1587 * x1 []
1588 * x2 []
1589 * x3 []
1590 * x4 []
1591 */
1592 BOOL WINAPI
1593 SynchronizeWindows31FilesAndWindowsNTRegistry( DWORD x1, DWORD x2, DWORD x3,
1594 DWORD x4 )
1595 {
1596 FIXME("(0x%08lx,0x%08lx,0x%08lx,0x%08lx):stub\n",x1,x2,x3,x4);
1597 return TRUE;
1598 }
1599
1600 /******************************************************************************
1601 * NotifyBootConfigStatus [ADVAPI32.@]
1602 *
1603 * PARAMS
1604 * x1 []
1605 */
1606 BOOL WINAPI
1607 NotifyBootConfigStatus( DWORD x1 )
1608 {
1609 FIXME("(0x%08lx):stub\n",x1);
1610 return 1;
1611 }
1612
1613 /******************************************************************************
1614 * RevertToSelf [ADVAPI32.@]
1615 *
1616 * Ends the impersonation of a user.
1617 *
1618 * PARAMS
1619 * void []
1620 *
1621 * RETURNS
1622 * Success: TRUE.
1623 * Failure: FALSE.
1624 */
1625 BOOL WINAPI
1626 RevertToSelf( void )
1627 {
1628 HANDLE Token = NULL;
1629 return set_ntstatus( NtSetInformationThread( GetCurrentThread(),
1630 ThreadImpersonationToken, &Token, sizeof(Token) ) );
1631 }
1632
1633 /******************************************************************************
1634 * ImpersonateSelf [ADVAPI32.@]
1635 *
1636 * Makes an impersonation token that represents the process user and assigns
1637 * to the current thread.
1638 *
1639 * PARAMS
1640 * ImpersonationLevel [I] Level at which to impersonate.
1641 *
1642 * RETURNS
1643 * Success: TRUE.
1644 * Failure: FALSE.
1645 */
1646 BOOL WINAPI
1647 ImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel)
1648 {
1649 return set_ntstatus( RtlImpersonateSelf( ImpersonationLevel ) );
1650 }
1651
1652 /******************************************************************************
1653 * ImpersonateLoggedOnUser [ADVAPI32.@]
1654 */
1655 BOOL WINAPI ImpersonateLoggedOnUser(HANDLE hToken)
1656 {
1657 FIXME("(%p):stub returning FALSE\n", hToken);
1658 return FALSE;
1659 }
1660
1661 /******************************************************************************
1662 * AccessCheck [ADVAPI32.@]
1663 */
1664 BOOL WINAPI
1665 AccessCheck(
1666 PSECURITY_DESCRIPTOR SecurityDescriptor,
1667 HANDLE ClientToken,
1668 DWORD DesiredAccess,
1669 PGENERIC_MAPPING GenericMapping,
1670 PPRIVILEGE_SET PrivilegeSet,
1671 LPDWORD PrivilegeSetLength,
1672 LPDWORD GrantedAccess,
1673 LPBOOL AccessStatus)
1674 {
1675 NTSTATUS access_status;
1676 BOOL ret = set_ntstatus( NtAccessCheck(SecurityDescriptor, ClientToken, DesiredAccess,
1677 GenericMapping, PrivilegeSet, PrivilegeSetLength,
1678 GrantedAccess, &access_status) );
1679 if (ret) *AccessStatus = set_ntstatus( access_status );
1680 return ret;
1681 }
1682
1683
1684 /******************************************************************************
1685 * AccessCheckByType [ADVAPI32.@]
1686 */
1687 BOOL WINAPI AccessCheckByType(
1688 PSECURITY_DESCRIPTOR pSecurityDescriptor,
1689 PSID PrincipalSelfSid,
1690 HANDLE ClientToken,
1691 DWORD DesiredAccess,
1692 POBJECT_TYPE_LIST ObjectTypeList,
1693 DWORD ObjectTypeListLength,
1694 PGENERIC_MAPPING GenericMapping,
1695 PPRIVILEGE_SET PrivilegeSet,
1696 LPDWORD PrivilegeSetLength,
1697 LPDWORD GrantedAccess,
1698 LPBOOL AccessStatus)
1699 {
1700 FIXME("stub\n");
1701
1702 *AccessStatus = TRUE;
1703
1704 return !*AccessStatus;
1705 }
1706
1707 /******************************************************************************
1708 * MapGenericMask [ADVAPI32.@]
1709 *
1710 * Maps generic access rights into specific access rights according to the
1711 * supplied mapping.
1712 *
1713 * PARAMS
1714 * AccessMask [I/O] Access rights.
1715 * GenericMapping [I] The mapping between generic and specific rights.
1716 *
1717 * RETURNS
1718 * Nothing.
1719 */
1720 VOID WINAPI MapGenericMask( PDWORD AccessMask, PGENERIC_MAPPING GenericMapping )
1721 {
1722 RtlMapGenericMask( AccessMask, GenericMapping );
1723 }
1724
1725 /*************************************************************************
1726 * SetKernelObjectSecurity [ADVAPI32.@]
1727 */
1728 BOOL WINAPI SetKernelObjectSecurity (
1729 IN HANDLE Handle,
1730 IN SECURITY_INFORMATION SecurityInformation,
1731 IN PSECURITY_DESCRIPTOR SecurityDescriptor )
1732 {
1733 return set_ntstatus (NtSetSecurityObject (Handle, SecurityInformation, SecurityDescriptor));
1734 }
1735
1736
1737 /******************************************************************************
1738 * AddAuditAccessAce [ADVAPI32.@]
1739 */
1740 BOOL WINAPI AddAuditAccessAce(
1741 IN OUT PACL pAcl,
1742 IN DWORD dwAceRevision,
1743 IN DWORD dwAccessMask,
1744 IN PSID pSid,
1745 IN BOOL bAuditSuccess,
1746 IN BOOL bAuditFailure)
1747 {
1748 return set_ntstatus( RtlAddAuditAccessAce(pAcl, dwAceRevision, dwAccessMask, pSid,
1749 bAuditSuccess, bAuditFailure) );
1750 }
1751
1752 /******************************************************************************
1753 * LookupAccountNameA [ADVAPI32.@]
1754 */
1755 BOOL WINAPI
1756 LookupAccountNameA(
1757 IN LPCSTR system,
1758 IN LPCSTR account,
1759 OUT PSID sid,
1760 OUT LPDWORD cbSid,
1761 LPSTR ReferencedDomainName,
1762 IN OUT LPDWORD cbReferencedDomainName,
1763 OUT PSID_NAME_USE name_use )
1764 {
1765 /* Default implementation: Always return a default SID */
1766 SID_IDENTIFIER_AUTHORITY identifierAuthority = {SECURITY_NT_AUTHORITY};
1767 BOOL ret;
1768 PSID pSid;
1769 static const char dm[] = "DOMAIN";
1770
1771 FIXME("(%s,%s,%p,%p,%p,%p,%p), stub.\n",system,account,sid,cbSid,ReferencedDomainName,cbReferencedDomainName,name_use);
1772
1773 ret = AllocateAndInitializeSid(&identifierAuthority,
1774 2,
1775 SECURITY_BUILTIN_DOMAIN_RID,
1776 DOMAIN_ALIAS_RID_ADMINS,
1777 0, 0, 0, 0, 0, 0,
1778 &pSid);
1779
1780 if (!ret)
1781 return FALSE;
1782 if(!RtlValidSid(pSid))
1783 {
1784 FreeSid(pSid);
1785 return FALSE;
1786 }
1787
1788 if (sid != NULL && (*cbSid >= GetLengthSid(pSid)))
1789 CopySid(*cbSid, sid, pSid);
1790 if (*cbSid < GetLengthSid(pSid))
1791 {
1792 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1793 ret = FALSE;
1794 }
1795 *cbSid = GetLengthSid(pSid);
1796
1797 if (ReferencedDomainName != NULL && (*cbReferencedDomainName > strlen(dm)))
1798 strcpy(ReferencedDomainName, dm);
1799 if (*cbReferencedDomainName <= strlen(dm))
1800 {
1801 SetLastError(ERROR_INSUFFICIENT_BUFFER);
1802 ret = FALSE;
1803 }
1804 *cbReferencedDomainName = strlen(dm)+1;
1805
1806 FreeSid(pSid);
1807
1808 return ret;
1809 }
1810
1811 /******************************************************************************
1812 * LookupAccountNameW [ADVAPI32.@]
1813 */
1814 BOOL WINAPI LookupAccountNameW( LPCWSTR lpSystemName, LPCWSTR lpAccountName, PSID Sid,
1815 LPDWORD cbSid, LPWSTR ReferencedDomainName,
1816 LPDWORD cchReferencedDomainName, PSID_NAME_USE peUse )
1817 {
1818 FIXME("%s %s %p %p %p %p %p - stub\n", debugstr_w(lpSystemName), debugstr_w(lpAccountName),
1819 Sid, cbSid, ReferencedDomainName, cchReferencedDomainName, peUse);
1820
1821 return FALSE;
1822 }
1823
1824 /******************************************************************************
1825 * PrivilegeCheck [ADVAPI32.@]
1826 */
1827 BOOL WINAPI PrivilegeCheck( HANDLE ClientToken, PPRIVILEGE_SET RequiredPrivileges, LPBOOL pfResult)
1828 {
1829 BOOL ret;
1830 BOOLEAN Result;
1831
1832 TRACE("%p %p %p\n", ClientToken, RequiredPrivileges, pfResult);
1833
1834 ret = set_ntstatus (NtPrivilegeCheck (ClientToken, RequiredPrivileges, &Result));
1835 if (ret)
1836 *pfResult = Result;
1837 return ret;
1838 }
1839
1840 /******************************************************************************
1841 * AccessCheckAndAuditAlarmA [ADVAPI32.@]
1842 */
1843 BOOL WINAPI AccessCheckAndAuditAlarmA(LPCSTR Subsystem, LPVOID HandleId, LPSTR ObjectTypeName,
1844 LPSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess,
1845 PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess,
1846 LPBOOL AccessStatus, LPBOOL pfGenerateOnClose)
1847 {
1848 FIXME("stub (%s,%p,%s,%s,%p,%08lx,%p,%x,%p,%p,%p)\n", debugstr_a(Subsystem),
1849 HandleId, debugstr_a(ObjectTypeName), debugstr_a(ObjectName),
1850 SecurityDescriptor, DesiredAccess, GenericMapping,
1851 ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose);
1852 return TRUE;
1853 }
1854
1855 /******************************************************************************
1856 * AccessCheckAndAuditAlarmW [ADVAPI32.@]
1857 */
1858 BOOL WINAPI AccessCheckAndAuditAlarmW(LPCWSTR Subsystem, LPVOID HandleId, LPWSTR ObjectTypeName,
1859 LPWSTR ObjectName, PSECURITY_DESCRIPTOR SecurityDescriptor, DWORD DesiredAccess,
1860 PGENERIC_MAPPING GenericMapping, BOOL ObjectCreation, LPDWORD GrantedAccess,
1861 LPBOOL AccessStatus, LPBOOL pfGenerateOnClose)
1862 {
1863 FIXME("stub (%s,%p,%s,%s,%p,%08lx,%p,%x,%p,%p,%p)\n", debugstr_w(Subsystem),
1864 HandleId, debugstr_w(ObjectTypeName), debugstr_w(ObjectName),
1865 SecurityDescriptor, DesiredAccess, GenericMapping,
1866 ObjectCreation, GrantedAccess, AccessStatus, pfGenerateOnClose);
1867 return TRUE;
1868 }
1869
1870 BOOL WINAPI ObjectCloseAuditAlarmA(LPCSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose)
1871 {
1872 FIXME("stub (%s,%p,%x)\n", debugstr_a(SubsystemName), HandleId, GenerateOnClose);
1873
1874 return TRUE;
1875 }
1876
1877 BOOL WINAPI ObjectCloseAuditAlarmW(LPCWSTR SubsystemName, LPVOID HandleId, BOOL GenerateOnClose)
1878 {
1879 FIXME("stub (%s,%p,%x)\n", debugstr_w(SubsystemName), HandleId, GenerateOnClose);
1880
1881 return TRUE;
1882 }
1883
1884 BOOL WINAPI ObjectOpenAuditAlarmA(LPCSTR SubsystemName, LPVOID HandleId, LPSTR ObjectTypeName,
1885 LPSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess,
1886 DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted,
1887 LPBOOL GenerateOnClose)
1888 {
1889 FIXME("stub (%s,%p,%s,%s,%p,%p,0x%08lx,0x%08lx,%p,%x,%x,%p)\n", debugstr_a(SubsystemName),
1890 HandleId, debugstr_a(ObjectTypeName), debugstr_a(ObjectName), pSecurityDescriptor,
1891 ClientToken, DesiredAccess, GrantedAccess, Privileges, ObjectCreation, AccessGranted,
1892 GenerateOnClose);
1893
1894 return TRUE;
1895 }
1896
1897 BOOL WINAPI ObjectOpenAuditAlarmW(LPCWSTR SubsystemName, LPVOID HandleId, LPWSTR ObjectTypeName,
1898 LPWSTR ObjectName, PSECURITY_DESCRIPTOR pSecurityDescriptor, HANDLE ClientToken, DWORD DesiredAccess,
1899 DWORD GrantedAccess, PPRIVILEGE_SET Privileges, BOOL ObjectCreation, BOOL AccessGranted,
1900 LPBOOL GenerateOnClose)
1901 {
1902 FIXME("stub (%s,%p,%s,%s,%p,%p,0x%08lx,0x%08lx,%p,%x,%x,%p)\n", debugstr_w(SubsystemName),
1903 HandleId, debugstr_w(ObjectTypeName), debugstr_w(ObjectName), pSecurityDescriptor,
1904 ClientToken, DesiredAccess, GrantedAccess, Privileges, ObjectCreation, AccessGranted,
1905 GenerateOnClose);
1906
1907 return TRUE;
1908 }
1909
1910 BOOL WINAPI ObjectPrivilegeAuditAlarmA( LPCSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken,
1911 DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted)
1912 {
1913 FIXME("stub (%s,%p,%p,0x%08lx,%p,%x)\n", debugstr_a(SubsystemName), HandleId, ClientToken,
1914 DesiredAccess, Privileges, AccessGranted);
1915
1916 return TRUE;
1917 }
1918
1919 BOOL WINAPI ObjectPrivilegeAuditAlarmW( LPCWSTR SubsystemName, LPVOID HandleId, HANDLE ClientToken,
1920 DWORD DesiredAccess, PPRIVILEGE_SET Privileges, BOOL AccessGranted)
1921 {
1922 FIXME("stub (%s,%p,%p,0x%08lx,%p,%x)\n", debugstr_w(SubsystemName), HandleId, ClientToken,
1923 DesiredAccess, Privileges, AccessGranted);
1924
1925 return TRUE;
1926 }
1927
1928 BOOL WINAPI PrivilegedServiceAuditAlarmA( LPCSTR SubsystemName, LPCSTR ServiceName, HANDLE ClientToken,
1929 PPRIVILEGE_SET Privileges, BOOL AccessGranted)
1930 {
1931 FIXME("stub (%s,%s,%p,%p,%x)\n", debugstr_a(SubsystemName), debugstr_a(ServiceName),
1932 ClientToken, Privileges, AccessGranted);
1933
1934 return TRUE;
1935 }
1936
1937 BOOL WINAPI PrivilegedServiceAuditAlarmW( LPCWSTR SubsystemName, LPCWSTR ServiceName, HANDLE ClientToken,
1938 PPRIVILEGE_SET Privileges, BOOL AccessGranted)
1939 {
1940 FIXME("stub %s,%s,%p,%p,%x)\n", debugstr_w(SubsystemName), debugstr_w(ServiceName),
1941 ClientToken, Privileges, AccessGranted);
1942
1943 return TRUE;
1944 }
1945
1946 /******************************************************************************
1947 * GetSecurityInfo [ADVAPI32.@]
1948 */
1949 DWORD WINAPI GetSecurityInfo(
1950 HANDLE hObject, SE_OBJECT_TYPE ObjectType,
1951 SECURITY_INFORMATION SecurityInfo, PSID *ppsidOwner,
1952 PSID *ppsidGroup, PACL *ppDacl, PACL *ppSacl,
1953 PSECURITY_DESCRIPTOR *ppSecurityDescriptor
1954 )
1955 {
1956 FIXME("stub!\n");
1957 return ERROR_BAD_PROVIDER;
1958 }
1959
1960 /******************************************************************************
1961 * GetSecurityInfoExW [ADVAPI32.@]
1962 */
1963 DWORD WINAPI GetSecurityInfoExW(
1964 HANDLE hObject, SE_OBJECT_TYPE ObjectType,
1965 SECURITY_INFORMATION SecurityInfo, LPCWSTR lpProvider,
1966 LPCWSTR lpProperty, PACTRL_ACCESSW *ppAccessList,
1967 PACTRL_AUDITW *ppAuditList, LPWSTR *lppOwner, LPWSTR *lppGroup
1968 )
1969 {
1970 FIXME("stub!\n");
1971 return ERROR_BAD_PROVIDER;
1972 }
1973
1974 /******************************************************************************
1975 * BuildExplicitAccessWithNameA [ADVAPI32.@]
1976 */
1977 VOID WINAPI BuildExplicitAccessWithNameA( PEXPLICIT_ACCESSA pExplicitAccess,
1978 LPSTR pTrusteeName, DWORD AccessPermissions,
1979 ACCESS_MODE AccessMode, DWORD Inheritance )
1980 {
1981 TRACE("%p %s 0x%08lx 0x%08x 0x%08lx\n", pExplicitAccess, debugstr_a(pTrusteeName),
1982 AccessPermissions, AccessMode, Inheritance);
1983
1984 pExplicitAccess->grfAccessPermissions = AccessPermissions;
1985 pExplicitAccess->grfAccessMode = AccessMode;
1986 pExplicitAccess->grfInheritance = Inheritance;
1987
1988 pExplicitAccess->Trustee.pMultipleTrustee = NULL;
1989 pExplicitAccess->Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
1990 pExplicitAccess->Trustee.TrusteeForm = TRUSTEE_IS_NAME;
1991 pExplicitAccess->Trustee.TrusteeType = TRUSTEE_IS_UNKNOWN;
1992 pExplicitAccess->Trustee.ptstrName = pTrusteeName;
1993 }
1994
1995 /******************************************************************************
1996 * BuildExplicitAccessWithNameW [ADVAPI32.@]
1997 */
1998 VOID WINAPI BuildExplicitAccessWithNameW( PEXPLICIT_ACCESSW pExplicitAccess,
1999 LPWSTR pTrusteeName, DWORD AccessPermissions,
2000 ACCESS_MODE AccessMode, DWORD Inheritance )
2001 {
2002 TRACE("%p %s 0x%08lx 0x%08x 0x%08lx\n", pExplicitAccess, debugstr_w(pTrusteeName),
2003 AccessPermissions, AccessMode, Inheritance);
2004
2005 pExplicitAccess->grfAccessPermissions = AccessPermissions;
2006 pExplicitAccess->grfAccessMode = AccessMode;
2007 pExplicitAccess->grfInheritance = Inheritance;
2008
2009 pExplicitAccess->Trustee.pMultipleTrustee = NULL;
2010 pExplicitAccess->Trustee.MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2011 pExplicitAccess->Trustee.TrusteeForm = TRUSTEE_IS_NAME;
2012 pExplicitAccess->Trustee.TrusteeType = TRUSTEE_IS_UNKNOWN;
2013 pExplicitAccess->Trustee.ptstrName = pTrusteeName;
2014 }
2015
2016 /******************************************************************************
2017 * BuildTrusteeWithObjectsAndNameA [ADVAPI32.@]
2018 */
2019 VOID WINAPI BuildTrusteeWithObjectsAndNameA( PTRUSTEEA pTrustee, POBJECTS_AND_NAME_A pObjName,
2020 SE_OBJECT_TYPE ObjectType, LPSTR ObjectTypeName,
2021 LPSTR InheritedObjectTypeName, LPSTR Name )
2022 {
2023 TRACE("%p %p 0x%08x %p %p %s\n", pTrustee, pObjName,
2024 ObjectType, ObjectTypeName, InheritedObjectTypeName, debugstr_a(Name));
2025
2026 pTrustee->pMultipleTrustee = NULL;
2027 pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2028 pTrustee->TrusteeForm = TRUSTEE_IS_OBJECTS_AND_NAME;
2029 pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2030 pTrustee->ptstrName = Name;
2031 }
2032
2033 /******************************************************************************
2034 * BuildTrusteeWithObjectsAndNameW [ADVAPI32.@]
2035 */
2036 VOID WINAPI BuildTrusteeWithObjectsAndNameW( PTRUSTEEW pTrustee, POBJECTS_AND_NAME_W pObjName,
2037 SE_OBJECT_TYPE ObjectType, LPWSTR ObjectTypeName,
2038 LPWSTR InheritedObjectTypeName, LPWSTR Name )
2039 {
2040 TRACE("%p %p 0x%08x %p %p %s\n", pTrustee, pObjName,
2041 ObjectType, ObjectTypeName, InheritedObjectTypeName, debugstr_w(Name));
2042
2043 pTrustee->pMultipleTrustee = NULL;
2044 pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2045 pTrustee->TrusteeForm = TRUSTEE_IS_OBJECTS_AND_NAME;
2046 pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2047 pTrustee->ptstrName = Name;
2048 }
2049
2050 VOID WINAPI BuildTrusteeWithObjectsAndSidA( PTRUSTEEA pTrustee, POBJECTS_AND_SID pObjSid,
2051 GUID* pObjectGuid, GUID* pInheritedObjectGuid, PSID pSid )
2052 {
2053 TRACE("%p %p %p %p %p\n", pTrustee, pObjSid, pObjectGuid, pInheritedObjectGuid, pSid);
2054
2055 pTrustee->pMultipleTrustee = NULL;
2056 pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2057 pTrustee->TrusteeForm = TRUSTEE_IS_OBJECTS_AND_SID;
2058 pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2059 pTrustee->ptstrName = (LPSTR) pSid;
2060 }
2061
2062 VOID WINAPI BuildTrusteeWithObjectsAndSidW( PTRUSTEEW pTrustee, POBJECTS_AND_SID pObjSid,
2063 GUID* pObjectGuid, GUID* pInheritedObjectGuid, PSID pSid )
2064 {
2065 TRACE("%p %p %p %p %p\n", pTrustee, pObjSid, pObjectGuid, pInheritedObjectGuid, pSid);
2066
2067 pTrustee->pMultipleTrustee = NULL;
2068 pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2069 pTrustee->TrusteeForm = TRUSTEE_IS_OBJECTS_AND_SID;
2070 pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2071 pTrustee->ptstrName = (LPWSTR) pSid;
2072 }
2073
2074 /******************************************************************************
2075 * BuildTrusteeWithSidA [ADVAPI32.@]
2076 */
2077 VOID WINAPI BuildTrusteeWithSidA(PTRUSTEEA pTrustee, PSID pSid)
2078 {
2079 TRACE("%p %p\n", pTrustee, pSid);
2080
2081 pTrustee->pMultipleTrustee = NULL;
2082 pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2083 pTrustee->TrusteeForm = TRUSTEE_IS_SID;
2084 pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2085 pTrustee->ptstrName = (LPSTR) pSid;
2086 }
2087
2088 /******************************************************************************
2089 * BuildTrusteeWithSidW [ADVAPI32.@]
2090 */
2091 VOID WINAPI BuildTrusteeWithSidW(PTRUSTEEW pTrustee, PSID pSid)
2092 {
2093 TRACE("%p %p\n", pTrustee, pSid);
2094
2095 pTrustee->pMultipleTrustee = NULL;
2096 pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2097 pTrustee->TrusteeForm = TRUSTEE_IS_SID;
2098 pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2099 pTrustee->ptstrName = (LPWSTR) pSid;
2100 }
2101
2102 /******************************************************************************
2103 * BuildTrusteeWithNameA [ADVAPI32.@]
2104 */
2105 VOID WINAPI BuildTrusteeWithNameA(PTRUSTEEA pTrustee, LPSTR name)
2106 {
2107 TRACE("%p %s\n", pTrustee, debugstr_a(name) );
2108
2109 pTrustee->pMultipleTrustee = NULL;
2110 pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2111 pTrustee->TrusteeForm = TRUSTEE_IS_NAME;
2112 pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2113 pTrustee->ptstrName = name;
2114 }
2115
2116 /******************************************************************************
2117 * BuildTrusteeWithNameW [ADVAPI32.@]
2118 */
2119 VOID WINAPI BuildTrusteeWithNameW(PTRUSTEEW pTrustee, LPWSTR name)
2120 {
2121 TRACE("%p %s\n", pTrustee, debugstr_w(name) );
2122
2123 pTrustee->pMultipleTrustee = NULL;
2124 pTrustee->MultipleTrusteeOperation = NO_MULTIPLE_TRUSTEE;
2125 pTrustee->TrusteeForm = TRUSTEE_IS_NAME;
2126 pTrustee->TrusteeType = TRUSTEE_IS_UNKNOWN;
2127 pTrustee->ptstrName = name;
2128 }
2129
2130 /******************************************************************************
2131 * GetTrusteeFormA [ADVAPI32.@]
2132 */
2133 TRUSTEE_FORM WINAPI GetTrusteeFormA(PTRUSTEEA pTrustee)
2134 {
2135 TRACE("(%p)\n", pTrustee);
2136
2137 if (!pTrustee)
2138 return TRUSTEE_BAD_FORM;
2139
2140 return pTrustee->TrusteeForm;
2141 }
2142
2143 /******************************************************************************
2144 * GetTrusteeFormW [ADVAPI32.@]
2145 */
2146 TRUSTEE_FORM WINAPI GetTrusteeFormW(PTRUSTEEW pTrustee)
2147 {
2148 TRACE("(%p)\n", pTrustee);
2149
2150 if (!pTrustee)
2151 return TRUSTEE_BAD_FORM;
2152
2153 return pTrustee->TrusteeForm;
2154 }
2155
2156 /******************************************************************************
2157 * GetTrusteeNameA [ADVAPI32.@]
2158 */
2159 LPSTR WINAPI GetTrusteeNameA(PTRUSTEEA pTrustee)
2160 {
2161 TRACE("(%p)\n", pTrustee);
2162
2163 if (!pTrustee)
2164 return NULL;
2165
2166 return pTrustee->ptstrName;
2167 }
2168
2169 /******************************************************************************
2170 * GetTrusteeNameW [ADVAPI32.@]
2171 */
2172 LPWSTR WINAPI GetTrusteeNameW(PTRUSTEEW pTrustee)
2173 {
2174 TRACE("(%p)\n", pTrustee);
2175
2176 if (!pTrustee)
2177 return NULL;
2178
2179 return pTrustee->ptstrName;
2180 }
2181
2182 /******************************************************************************
2183 * GetTrusteeTypeA [ADVAPI32.@]
2184 */
2185 TRUSTEE_TYPE WINAPI GetTrusteeTypeA(PTRUSTEEA pTrustee)
2186 {
2187 TRACE("(%p)\n", pTrustee);
2188
2189 if (!pTrustee)
2190 return TRUSTEE_IS_UNKNOWN;
2191
2192 return pTrustee->TrusteeType;
2193 }
2194
2195 /******************************************************************************
2196 * GetTrusteeTypeW [ADVAPI32.@]
2197 */
2198 TRUSTEE_TYPE WINAPI GetTrusteeTypeW(PTRUSTEEW pTrustee)
2199 {
2200 TRACE("(%p)\n", pTrustee);
2201
2202 if (!pTrustee)
2203 return TRUSTEE_IS_UNKNOWN;
2204
2205 return pTrustee->TrusteeType;
2206 }
2207
2208 BOOL WINAPI SetAclInformation( PACL pAcl, LPVOID pAclInformation,
2209 DWORD nAclInformationLength,
2210 ACL_INFORMATION_CLASS dwAclInformationClass )
2211 {
2212 FIXME("%p %p 0x%08lx 0x%08x - stub\n", pAcl, pAclInformation,
2213 nAclInformationLength, dwAclInformationClass);
2214
2215 return TRUE;
2216 }
2217
2218 /******************************************************************************
2219 * SetEntriesInAclA [ADVAPI32.@]
2220 */
2221 DWORD WINAPI SetEntriesInAclA( ULONG count, PEXPLICIT_ACCESSA pEntries,
2222 PACL OldAcl, PACL* NewAcl )
2223 {
2224 FIXME("%ld %p %p %p\n",count,pEntries,OldAcl,NewAcl);
2225 return ERROR_CALL_NOT_IMPLEMENTED;
2226 }
2227
2228 /******************************************************************************
2229 * SetEntriesInAclW [ADVAPI32.@]
2230 */
2231 DWORD WINAPI SetEntriesInAclW( ULONG count, PEXPLICIT_ACCESSW pEntries,
2232 PACL OldAcl, PACL* NewAcl )
2233 {
2234 FIXME("%ld %p %p %p\n",count,pEntries,OldAcl,NewAcl);
2235 return ERROR_CALL_NOT_IMPLEMENTED;
2236 }
2237
2238 /******************************************************************************
2239 * SetNamedSecurityInfoA [ADVAPI32.@]
2240 */
2241 DWORD WINAPI SetNamedSecurityInfoA(LPSTR pObjectName,
2242 SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo,
2243 PSID psidOwner, PSID psidGroup, PACL pDacl, PACL pSacl)
2244 {
2245 DWORD len;
2246 LPWSTR wstr = NULL;
2247 DWORD r;
2248
2249 TRACE("%s %d %ld %p %p %p %p\n", debugstr_a(pObjectName), ObjectType,
2250 SecurityInfo, psidOwner, psidGroup, pDacl, pSacl);
2251
2252 if( pObjectName )
2253 {
2254 len = MultiByteToWideChar( CP_ACP, 0, pObjectName, -1, NULL, 0 );
2255 wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR));
2256 MultiByteToWideChar( CP_ACP, 0, pObjectName, -1, wstr, len );
2257 }
2258
2259 r = SetNamedSecurityInfoW( wstr, ObjectType, SecurityInfo, psidOwner,
2260 psidGroup, pDacl, pSacl );
2261
2262 HeapFree( GetProcessHeap(), 0, wstr );
2263
2264 return r;
2265 }
2266
2267 BOOL WINAPI SetPrivateObjectSecurity( SECURITY_INFORMATION SecurityInformation,
2268 PSECURITY_DESCRIPTOR ModificationDescriptor,
2269 PSECURITY_DESCRIPTOR* ObjectsSecurityDescriptor,
2270 PGENERIC_MAPPING GenericMapping,
2271 HANDLE Token )
2272 {
2273 FIXME("0x%08lx %p %p %p %p - stub\n", SecurityInformation, ModificationDescriptor,
2274 ObjectsSecurityDescriptor, GenericMapping, Token);
2275
2276 return TRUE;
2277 }
2278
2279 BOOL WINAPI SetSecurityDescriptorControl( PSECURITY_DESCRIPTOR pSecurityDescriptor,
2280 SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest,
2281 SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet )
2282 {
2283 FIXME("%p 0x%08x 0x%08x - stub\n", pSecurityDescriptor, ControlBitsOfInterest,
2284 ControlBitsToSet);
2285
2286 return TRUE;
2287 }
2288
2289 BOOL WINAPI AreAllAccessesGranted( DWORD GrantedAccess, DWORD DesiredAccess )
2290 {
2291 return RtlAreAllAccessesGranted( GrantedAccess, DesiredAccess );
2292 }
2293
2294 /******************************************************************************
2295 * AreAnyAccessesGranted [ADVAPI32.@]
2296 *
2297 * Determines whether or not any of a set of specified access permissions have
2298 * been granted or not.
2299 *
2300 * PARAMS
2301 * GrantedAccess [I] The permissions that have been granted.
2302 * DesiredAccess [I] The permissions that you want to have.
2303 *
2304 * RETURNS
2305 * Nonzero if any of the permissions have been granted, zero if none of the
2306 * permissions have been granted.
2307 */
2308
2309 BOOL WINAPI AreAnyAccessesGranted( DWORD GrantedAccess, DWORD DesiredAccess )
2310 {
2311 return RtlAreAnyAccessesGranted( GrantedAccess, DesiredAccess );
2312 }
2313
2314 /******************************************************************************
2315 * SetNamedSecurityInfoW [ADVAPI32.@]
2316 */
2317 DWORD WINAPI SetNamedSecurityInfoW(LPWSTR pObjectName,
2318 SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo,
2319 PSID psidOwner, PSID psidGroup, PACL pDacl, PACL pSacl)
2320 {
2321 FIXME("%s %d %ld %p %p %p %p\n", debugstr_w(pObjectName), ObjectType,
2322 SecurityInfo, psidOwner, psidGroup, pDacl, pSacl);
2323 return ERROR_SUCCESS;
2324 }
2325
2326 /******************************************************************************
2327 * GetExplicitEntriesFromAclA [ADVAPI32.@]
2328 */
2329 DWORD WINAPI GetExplicitEntriesFromAclA( PACL pacl, PULONG pcCountOfExplicitEntries,
2330 PEXPLICIT_ACCESSA* pListOfExplicitEntries)
2331 {
2332 FIXME("%p %p %p\n",pacl, pcCountOfExplicitEntries, pListOfExplicitEntries);
2333 return ERROR_CALL_NOT_IMPLEMENTED;
2334 }
2335
2336 /******************************************************************************
2337 * GetExplicitEntriesFromAclW [ADVAPI32.@]
2338 */
2339 DWORD WINAPI GetExplicitEntriesFromAclW( PACL pacl, PULONG pcCountOfExplicitEntries,
2340 PEXPLICIT_ACCESSW* pListOfExplicitEntries)
2341 {
2342 FIXME("%p %p %p\n",pacl, pcCountOfExplicitEntries, pListOfExplicitEntries);
2343 return ERROR_CALL_NOT_IMPLEMENTED;
2344 }
2345
2346
2347 /******************************************************************************
2348 * ParseAclStringFlags
2349 */
2350 static DWORD ParseAclStringFlags(LPCWSTR* StringAcl)
2351 {
2352 DWORD flags = 0;
2353 LPCWSTR szAcl = *StringAcl;
2354
2355 while (*szAcl != '(')
2356 {
2357 if (*szAcl == 'P')
2358 {
2359 flags |= SE_DACL_PROTECTED;
2360 }
2361 else if (*szAcl == 'A')
2362 {
2363 szAcl++;
2364 if (*szAcl == 'R')
2365 flags |= SE_DACL_AUTO_INHERIT_REQ;
2366 else if (*szAcl == 'I')
2367 flags |= SE_DACL_AUTO_INHERITED;
2368 }
2369 szAcl++;
2370 }
2371
2372 *StringAcl = szAcl;
2373 return flags;
2374 }
2375
2376 /******************************************************************************
2377 * ParseAceStringType
2378 */
2379 ACEFLAG AceType[] =
2380 {
2381 { SDDL_ACCESS_ALLOWED, ACCESS_ALLOWED_ACE_TYPE },
2382 { SDDL_ALARM, SYSTEM_ALARM_ACE_TYPE },
2383 { SDDL_AUDIT, SYSTEM_AUDIT_ACE_TYPE },
2384 { SDDL_ACCESS_DENIED, ACCESS_DENIED_ACE_TYPE },
2385 /*
2386 { SDDL_OBJECT_ACCESS_ALLOWED, ACCESS_ALLOWED_OBJECT_ACE_TYPE },
2387 { SDDL_OBJECT_ACCESS_DENIED, ACCESS_DENIED_OBJECT_ACE_TYPE },
2388 { SDDL_OBJECT_ALARM, SYSTEM_ALARM_OBJECT_ACE_TYPE },
2389 { SDDL_OBJECT_AUDIT, SYSTEM_AUDIT_OBJECT_ACE_TYPE },
2390 */
2391 { NULL, 0 },
2392 };
2393
2394 static BYTE ParseAceStringType(LPCWSTR* StringAcl)
2395 {
2396 UINT len = 0;
2397 LPCWSTR szAcl = *StringAcl;
2398 LPACEFLAG lpaf = AceType;
2399
2400 while (lpaf->wstr &&
2401 (len = strlenW(lpaf->wstr)) &&
2402 strncmpW(lpaf->wstr, szAcl, len))
2403 lpaf++;
2404
2405 if (!lpaf->wstr)
2406 return 0;
2407
2408 *StringAcl += len;
2409 return lpaf->value;
2410 }
2411
2412
2413 /******************************************************************************
2414 * ParseAceStringFlags
2415 */
2416 ACEFLAG AceFlags[] =
2417 {
2418 { SDDL_CONTAINER_INHERIT, CONTAINER_INHERIT_ACE },
2419 { SDDL_AUDIT_FAILURE, FAILED_ACCESS_ACE_FLAG },
2420 { SDDL_INHERITED, INHERITED_ACE },
2421 { SDDL_INHERIT_ONLY, INHERIT_ONLY_ACE },
2422 { SDDL_NO_PROPAGATE, NO_PROPAGATE_INHERIT_ACE },
2423 { SDDL_OBJECT_INHERIT, OBJECT_INHERIT_ACE },
2424 { SDDL_AUDIT_SUCCESS, SUCCESSFUL_ACCESS_ACE_FLAG },
2425 { NULL, 0 },
2426 };
2427
2428 static BYTE ParseAceStringFlags(LPCWSTR* StringAcl)
2429 {
2430 UINT len = 0;
2431 BYTE flags = 0;
2432 LPCWSTR szAcl = *StringAcl;
2433
2434 while (*szAcl != ';')
2435 {
2436 LPACEFLAG lpaf = AceFlags;
2437
2438 while (lpaf->wstr &&
2439 (len = strlenW(lpaf->wstr)) &&
2440 strncmpW(lpaf->wstr, szAcl, len))
2441 lpaf++;
2442
2443 if (!lpaf->wstr)
2444 return 0;
2445
2446 flags |= lpaf->value;
2447 szAcl += len;
2448 }
2449
2450 *StringAcl = szAcl;
2451 return flags;
2452 }
2453
2454
2455 /******************************************************************************
2456 * ParseAceStringRights
2457 */
2458 ACEFLAG AceRights[] =
2459 {
2460 { SDDL_GENERIC_ALL, GENERIC_ALL },
2461 { SDDL_GENERIC_READ, GENERIC_READ },
2462 { SDDL_GENERIC_WRITE, GENERIC_WRITE },
2463 { SDDL_GENERIC_EXECUTE, GENERIC_EXECUTE },
2464 { SDDL_READ_CONTROL, READ_CONTROL },
2465 { SDDL_STANDARD_DELETE, DELETE },
2466 { SDDL_WRITE_DAC, WRITE_DAC },
2467 { SDDL_WRITE_OWNER, WRITE_OWNER },
2468 { NULL, 0 },
2469 };
2470
2471 static DWORD ParseAceStringRights(LPCWSTR* StringAcl)
2472 {
2473 UINT len = 0;
2474 DWORD rights = 0;
2475 LPCWSTR szAcl = *StringAcl;
2476
2477 if ((*szAcl == '0') && (*(szAcl + 1) == 'x'))
2478 {
2479 LPCWSTR p = szAcl;
2480
2481 while (*p && *p != ';')
2482 p++;
2483
2484 if (p - szAcl <= 8)
2485 {
2486 rights = strtoulW(szAcl, NULL, 16);
2487 *StringAcl = p;
2488 }
2489 else
2490 WARN("Invalid rights string format: %s\n", debugstr_wn(szAcl, p - szAcl));
2491 }
2492 else
2493 {
2494 while (*szAcl != ';')
2495 {
2496 LPACEFLAG lpaf = AceRights;
2497
2498 while (lpaf->wstr &&
2499 (len = strlenW(lpaf->wstr)) &&
2500 strncmpW(lpaf->wstr, szAcl, len))
2501 {
2502 lpaf++;
2503 }
2504
2505 if (!lpaf->wstr)
2506 return 0;
2507
2508 rights |= lpaf->value;
2509 szAcl += len;
2510 }
2511 }
2512
2513 *StringAcl = szAcl;
2514 return rights;
2515 }
2516
2517
2518 /******************************************************************************
2519 * ParseStringAclToAcl
2520 *
2521 * dacl_flags(string_ace1)(string_ace2)... (string_acen)
2522 */
2523 static BOOL ParseStringAclToAcl(LPCWSTR StringAcl, LPDWORD lpdwFlags,
2524 PACL pAcl, LPDWORD cBytes)
2525 {
2526 DWORD val;
2527 DWORD sidlen;
2528 DWORD length = sizeof(ACL);
2529 PACCESS_ALLOWED_ACE pAce = NULL; /* pointer to current ACE */
2530
2531 TRACE("%s\n", debugstr_w(StringAcl));
2532
2533 if (!StringAcl)
2534 return FALSE;
2535
2536 if (pAcl) /* pAce is only useful if we're setting values */
2537 pAce = (PACCESS_ALLOWED_ACE) ((LPBYTE)pAcl + sizeof(PACL));
2538
2539 /* Parse ACL flags */
2540 *lpdwFlags = ParseAclStringFlags(&StringAcl);
2541
2542 /* Parse ACE */
2543 while (*StringAcl == '(')
2544 {
2545 StringAcl++;
2546
2547 /* Parse ACE type */
2548 val = ParseAceStringType(&StringAcl);
2549 if (pAce)
2550 pAce->Header.AceType = (BYTE) val;
2551 if (*StringAcl != ';')
2552 goto lerr;
2553 StringAcl++;
2554
2555 /* Parse ACE flags */
2556 val = ParseAceStringFlags(&StringAcl);
2557 if (pAce)
2558 pAce->Header.AceFlags = (BYTE) val;
2559 if (*StringAcl != ';')
2560 goto lerr;
2561 StringAcl++;
2562
2563 /* Parse ACE rights */
2564 val = ParseAceStringRights(&StringAcl);
2565 if (pAce)
2566 pAce->Mask = val;
2567 if (*StringAcl != ';')
2568 goto lerr;
2569 StringAcl++;
2570
2571 /* Parse ACE object guid */
2572 if (*StringAcl != ';')
2573 {
2574 FIXME("Support for *_OBJECT_ACE_TYPE not implemented\n");
2575 goto lerr;
2576 }
2577 StringAcl++;
2578
2579 /* Parse ACE inherit object guid */
2580 if (*StringAcl != ';')
2581 {
2582 FIXME("Support for *_OBJECT_ACE_TYPE not implemented\n");
2583 goto lerr;
2584 }
2585 StringAcl++;
2586
2587 /* Parse ACE account sid */
2588 if (ParseStringSidToSid(StringAcl, pAce ? (PSID)&pAce->SidStart : NULL, &sidlen))
2589 {
2590 while (*StringAcl && *StringAcl != ')')
2591 StringAcl++;
2592 }
2593
2594 if (*StringAcl != ')')
2595 goto lerr;
2596 StringAcl++;
2597
2598 length += sizeof(ACCESS_ALLOWED_ACE) - sizeof(DWORD) + sidlen;
2599 }
2600
2601 *cBytes = length;
2602 return TRUE;
2603
2604 lerr:
2605 WARN("Invalid ACE string format\n");
2606 return FALSE;
2607 }
2608
2609
2610 /******************************************************************************
2611 * ParseStringSecurityDescriptorToSecurityDescriptor
2612 */
2613 static BOOL ParseStringSecurityDescriptorToSecurityDescriptor(
2614 LPCWSTR StringSecurityDescriptor,
2615 SECURITY_DESCRIPTOR* SecurityDescriptor,
2616 LPDWORD cBytes)
2617 {
2618 BOOL bret = FALSE;
2619 WCHAR toktype;
2620 WCHAR tok[MAX_PATH];
2621 LPCWSTR lptoken;
2622 LPBYTE lpNext = NULL;
2623 DWORD len;
2624
2625 *cBytes = 0;
2626
2627 if (SecurityDescriptor)
2628 lpNext = ((LPBYTE) SecurityDescriptor) + sizeof(SECURITY_DESCRIPTOR);
2629
2630 while (*StringSecurityDescriptor)
2631 {
2632 toktype = *StringSecurityDescriptor;
2633
2634 /* Expect char identifier followed by ':' */
2635 StringSecurityDescriptor++;
2636 if (*StringSecurityDescriptor != ':')
2637 {
2638 SetLastError(ERROR_INVALID_PARAMETER);
2639 goto lend;
2640 }
2641 StringSecurityDescriptor++;
2642
2643 /* Extract token */
2644 lptoken = StringSecurityDescriptor;
2645 while (*lptoken && *lptoken != ':')
2646 lptoken++;
2647
2648 if (*lptoken)
2649 lptoken--;
2650
2651 len = lptoken - StringSecurityDescriptor;
2652 memcpy( tok, StringSecurityDescriptor, len * sizeof(WCHAR) );
2653 tok[len] = 0;
2654
2655 switch (toktype)
2656 {
2657 case 'O':
2658 {
2659 DWORD bytes;
2660
2661 if (!ParseStringSidToSid(tok, (PSID)lpNext, &bytes))
2662 goto lend;
2663
2664 if (SecurityDescriptor)
2665 {
2666 SecurityDescriptor->Owner = (PSID)(lpNext - (LPBYTE)SecurityDescriptor);
2667 lpNext += bytes; /* Advance to next token */
2668 }
2669
2670 *cBytes += bytes;
2671
2672 break;
2673 }
2674
2675 case 'G':
2676 {
2677 DWORD bytes;
2678
2679 if (!ParseStringSidToSid(tok, (PSID)lpNext, &bytes))
2680 goto lend;
2681
2682 if (SecurityDescriptor)
2683 {
2684 SecurityDescriptor->Group = (PSID)(lpNext - (LPBYTE)SecurityDescriptor);
2685 lpNext += bytes; /* Advance to next token */
2686 }
2687
2688 *cBytes += bytes;
2689
2690 break;
2691 }
2692
2693 case 'D':
2694 {
2695 DWORD flags;
2696 DWORD bytes;
2697
2698 if (!ParseStringAclToAcl(tok, &flags, (PACL)lpNext, &bytes))
2699 goto lend;
2700
2701 if (SecurityDescriptor)
2702 {
2703 SecurityDescriptor->Control |= SE_DACL_PRESENT | flags;
2704 SecurityDescriptor->Dacl = (PACL)(lpNext - (LPBYTE)SecurityDescriptor);
2705 lpNext += bytes; /* Advance to next token */
2706 }
2707
2708 *cBytes += bytes;
2709
2710 break;
2711 }
2712
2713 case 'S':
2714 {
2715 DWORD flags;
2716 DWORD bytes;
2717
2718 if (!ParseStringAclToAcl(tok, &flags, (PACL)lpNext, &bytes))
2719 goto lend;
2720
2721 if (SecurityDescriptor)
2722 {
2723 SecurityDescriptor->Control |= SE_SACL_PRESENT | flags;
2724 SecurityDescriptor->Sacl = (PACL)(lpNext - (LPBYTE)SecurityDescriptor);
2725 lpNext += bytes; /* Advance to next token */
2726 }
2727
2728 *cBytes += bytes;
2729
2730 break;
2731 }
2732
2733 default:
2734 FIXME("Unknown token\n");
2735 SetLastError(ERROR_INVALID_PARAMETER);
2736 goto lend;
2737 }
2738
2739 StringSecurityDescriptor = lptoken;
2740 }
2741
2742 bret = TRUE;
2743
2744 lend:
2745 return bret;
2746 }
2747
2748 /******************************************************************************
2749 * ConvertStringSecurityDescriptorToSecurityDescriptorA [ADVAPI32.@]
2750 */
2751 BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorA(
2752 LPCSTR StringSecurityDescriptor,
2753 DWORD StringSDRevision,
2754 PSECURITY_DESCRIPTOR* SecurityDescriptor,
2755 PULONG SecurityDescriptorSize)
2756 {
2757 UINT len;
2758 BOOL ret = FALSE;
2759 LPWSTR StringSecurityDescriptorW;
2760
2761 len = MultiByteToWideChar(CP_ACP, 0, StringSecurityDescriptor, -1, NULL, 0);
2762 StringSecurityDescriptorW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
2763
2764 if (StringSecurityDescriptorW)
2765 {
2766 MultiByteToWideChar(CP_ACP, 0, StringSecurityDescriptor, -1, StringSecurityDescriptorW, len);
2767
2768 ret = ConvertStringSecurityDescriptorToSecurityDescriptorW(StringSecurityDescriptorW,
2769 StringSDRevision, SecurityDescriptor,
2770 SecurityDescriptorSize);
2771 HeapFree(GetProcessHeap(), 0, StringSecurityDescriptorW);
2772 }
2773
2774 return ret;
2775 }
2776
2777 /******************************************************************************
2778 * ConvertStringSecurityDescriptorToSecurityDescriptorW [ADVAPI32.@]
2779 */
2780 BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorW(
2781 LPCWSTR StringSecurityDescriptor,
2782 DWORD StringSDRevision,
2783 PSECURITY_DESCRIPTOR* SecurityDescriptor,
2784 PULONG SecurityDescriptorSize)
2785 {
2786 DWORD cBytes;
2787 SECURITY_DESCRIPTOR* psd;
2788 BOOL bret = FALSE;
2789
2790 TRACE("%s\n", debugstr_w(StringSecurityDescriptor));
2791
2792 if (GetVersion() & 0x80000000)
2793 {
2794 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2795 goto lend;
2796 }
2797 else if (StringSDRevision != SID_REVISION)
2798 {
2799 SetLastError(ERROR_UNKNOWN_REVISION);
2800 goto lend;
2801 }
2802
2803 /* Compute security descriptor length */
2804 if (!ParseStringSecurityDescriptorToSecurityDescriptor(StringSecurityDescriptor,
2805 NULL, &cBytes))
2806 goto lend;
2807
2808 psd = *SecurityDescriptor = (SECURITY_DESCRIPTOR*) LocalAlloc(
2809 GMEM_ZEROINIT, cBytes);
2810
2811 psd->Revision = SID_REVISION;
2812 psd->Control |= SE_SELF_RELATIVE;
2813
2814 if (!ParseStringSecurityDescriptorToSecurityDescriptor(StringSecurityDescriptor,
2815 psd, &cBytes))
2816 {
2817 LocalFree(psd);
2818 goto lend;
2819 }
2820
2821 if (SecurityDescriptorSize)
2822 *SecurityDescriptorSize = cBytes;
2823
2824 bret = TRUE;
2825
2826 lend:
2827 TRACE(" ret=%d\n", bret);
2828 return bret;
2829 }
2830
2831 /******************************************************************************
2832 * ConvertStringSidToSidW [ADVAPI32.@]
2833 */
2834 BOOL WINAPI ConvertStringSidToSidW(LPCWSTR StringSid, PSID* Sid)
2835 {
2836 BOOL bret = FALSE;
2837 DWORD cBytes;
2838
2839 TRACE("%s, %p\n", debugstr_w(StringSid), Sid);
2840 if (GetVersion() & 0x80000000)
2841 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2842 else if (!StringSid || !Sid)
2843 SetLastError(ERROR_INVALID_PARAMETER);
2844 else if (ParseStringSidToSid(StringSid, NULL, &cBytes))
2845 {
2846 PSID pSid = *Sid = (PSID) LocalAlloc(0, cBytes);
2847
2848 bret = ParseStringSidToSid(StringSid, pSid, &cBytes);
2849 if (!bret)
2850 LocalFree(*Sid);
2851 }
2852 TRACE("returning %s\n", bret ? "TRUE" : "FALSE");
2853 return bret;
2854 }
2855
2856 /******************************************************************************
2857 * ConvertStringSidToSidA [ADVAPI32.@]
2858 */
2859 BOOL WINAPI ConvertStringSidToSidA(LPCSTR StringSid, PSID* Sid)
2860 {
2861 BOOL bret = FALSE;
2862
2863 TRACE("%s, %p\n", debugstr_a(StringSid), Sid);
2864 if (GetVersion() & 0x80000000)
2865 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2866 else if (!StringSid || !Sid)
2867 SetLastError(ERROR_INVALID_PARAMETER);
2868 else
2869 {
2870 UINT len = MultiByteToWideChar(CP_ACP, 0, StringSid, -1, NULL, 0);
2871 LPWSTR wStringSid = HeapAlloc(GetProcessHeap(), 0,
2872 len * sizeof(WCHAR));
2873
2874 MultiByteToWideChar(CP_ACP, 0, StringSid, -1, wStringSid, len);
2875 bret = ConvertStringSidToSidW(wStringSid, Sid);
2876 HeapFree(GetProcessHeap(), 0, wStringSid);
2877 }
2878 TRACE("returning %s\n", bret ? "TRUE" : "FALSE");
2879 return bret;
2880 }
2881
2882 /******************************************************************************
2883 * ConvertSidToStringSidW [ADVAPI32.@]
2884 *
2885 * format of SID string is:
2886 * S-<count>-<auth>-<subauth1>-<subauth2>-<subauth3>...
2887 * where
2888 * <rev> is the revision of the SID encoded as decimal
2889 * <auth> is the identifier authority encoded as hex
2890 * <subauthN> is the subauthority id encoded as decimal
2891 */
2892 BOOL WINAPI ConvertSidToStringSidW( PSID pSid, LPWSTR *pstr )
2893 {
2894 DWORD sz, i;
2895 LPWSTR str;
2896 WCHAR fmt[] = { 'S','-','%','u','-','%','d',0 };
2897 WCHAR subauthfmt[] = { '-','%','u',0 };
2898 SID* pisid=pSid;
2899
2900 TRACE("%p %p\n", pSid, pstr );
2901
2902 if( !IsValidSid( pSid ) )
2903 return FALSE;
2904
2905 if (pisid->Revision != SDDL_REVISION)
2906 return FALSE;
2907 if (pisid->IdentifierAuthority.Value[0] ||
2908 pisid->IdentifierAuthority.Value[1])
2909 {
2910 FIXME("not matching MS' bugs\n");
2911 return FALSE;
2912 }
2913
2914 sz = 14 + pisid->SubAuthorityCount * 11;
2915 str = LocalAlloc( 0, sz*sizeof(WCHAR) );
2916 sprintfW( str, fmt, pisid->Revision, MAKELONG(
2917 MAKEWORD( pisid->IdentifierAuthority.Value[5],
2918 pisid->IdentifierAuthority.Value[4] ),
2919 MAKEWORD( pisid->IdentifierAuthority.Value[3],
2920 pisid->IdentifierAuthority.Value[2] ) ) );
2921 for( i=0; i<pisid->SubAuthorityCount; i++ )
2922 sprintfW( str + strlenW(str), subauthfmt, pisid->SubAuthority[i] );
2923 *pstr = str;
2924
2925 return TRUE;
2926 }
2927
2928 /******************************************************************************
2929 * ConvertSidToStringSidA [ADVAPI32.@]
2930 */
2931 BOOL WINAPI ConvertSidToStringSidA(PSID pSid, LPSTR *pstr)
2932 {
2933 LPWSTR wstr = NULL;
2934 LPSTR str;
2935 UINT len;
2936
2937 TRACE("%p %p\n", pSid, pstr );
2938
2939 if( !ConvertSidToStringSidW( pSid, &wstr ) )
2940 return FALSE;
2941
2942 len = WideCharToMultiByte( CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL );
2943 str = LocalAlloc( 0, len );
2944 WideCharToMultiByte( CP_ACP, 0, wstr, -1, str, len, NULL, NULL );
2945 LocalFree( wstr );
2946
2947 *pstr = str;
2948
2949 return TRUE;
2950 }
2951
2952 BOOL WINAPI CreatePrivateObjectSecurity(
2953 PSECURITY_DESCRIPTOR ParentDescriptor,
2954 PSECURITY_DESCRIPTOR CreatorDescriptor,
2955 PSECURITY_DESCRIPTOR* NewDescriptor,
2956 BOOL IsDirectoryObject,
2957 HANDLE Token,
2958 PGENERIC_MAPPING GenericMapping )
2959 {
2960 FIXME("%p %p %p %d %p %p - stub\n", ParentDescriptor, CreatorDescriptor,
2961 NewDescriptor, IsDirectoryObject, Token, GenericMapping);
2962
2963 return FALSE;
2964 }
2965
2966 BOOL WINAPI DestroyPrivateObjectSecurity( PSECURITY_DESCRIPTOR* ObjectDescriptor )
2967 {
2968 FIXME("%p - stub\n", ObjectDescriptor);
2969
2970 return TRUE;
2971 }
2972
2973 BOOL WINAPI CreateProcessAsUserA(
2974 HANDLE hToken,
2975 LPCSTR lpApplicationName,
2976 LPSTR lpCommandLine,
2977 LPSECURITY_ATTRIBUTES lpProcessAttributes,
2978 LPSECURITY_ATTRIBUTES lpThreadAttributes,
2979 BOOL bInheritHandles,
2980 DWORD dwCreationFlags,
2981 LPVOID lpEnvironment,
2982 LPCSTR lpCurrentDirectory,
2983 LPSTARTUPINFOA lpStartupInfo,
2984 LPPROCESS_INFORMATION lpProcessInformation )
2985 {
2986 FIXME("%p %s %s %p %p %d 0x%08lx %p %s %p %p - stub\n", hToken, debugstr_a(lpApplicationName),
2987 debugstr_a(lpCommandLine), lpProcessAttributes, lpThreadAttributes, bInheritHandles,
2988 dwCreationFlags, lpEnvironment, debugstr_a(lpCurrentDirectory), lpStartupInfo, lpProcessInformation);
2989
2990 return FALSE;
2991 }
2992
2993 BOOL WINAPI CreateProcessAsUserW(
2994 HANDLE hToken,
2995 LPCWSTR lpApplicationName,
2996 LPWSTR lpCommandLine,
2997 LPSECURITY_ATTRIBUTES lpProcessAttributes,
2998 LPSECURITY_ATTRIBUTES lpThreadAttributes,
2999 BOOL bInheritHandles,
3000 DWORD dwCreationFlags,
3001 LPVOID lpEnvironment,
3002 LPCWSTR lpCurrentDirectory,
3003 LPSTARTUPINFOW lpStartupInfo,
3004 LPPROCESS_INFORMATION lpProcessInformation )
3005 {
3006 FIXME("%p %s %s %p %p %d 0x%08lx %p %s %p %p - semi- stub\n", hToken,
3007 debugstr_w(lpApplicationName), debugstr_w(lpCommandLine), lpProcessAttributes,
3008 lpThreadAttributes, bInheritHandles, dwCreationFlags, lpEnvironment,
3009 debugstr_w(lpCurrentDirectory), lpStartupInfo, lpProcessInformation);
3010
3011 /* We should create the process with a suspended main thread */
3012 if (!CreateProcessW (lpApplicationName,
3013 lpCommandLine,
3014 lpProcessAttributes,
3015 lpThreadAttributes,
3016 bInheritHandles,
3017 dwCreationFlags, /* CREATE_SUSPENDED */
3018 lpEnvironment,
3019 lpCurrentDirectory,
3020 lpStartupInfo,
3021 lpProcessInformation))
3022 {
3023 return FALSE;
3024 }
3025
3026 return TRUE;
3027 }
3028
3029 /******************************************************************************
3030 * ComputeStringSidSize
3031 */
3032 static DWORD ComputeStringSidSize(LPCWSTR StringSid)
3033 {
3034 int ctok = 0;
3035 DWORD size = sizeof(SID);
3036
3037 while (*StringSid)
3038 {
3039 if (*StringSid == '-')
3040 ctok++;
3041 StringSid++;
3042 }
3043
3044 if (ctok > 3)
3045 size += (ctok - 3) * sizeof(DWORD);
3046
3047 return size;
3048 }
3049
3050 BOOL WINAPI DuplicateTokenEx(
3051 HANDLE ExistingTokenHandle, DWORD dwDesiredAccess,
3052 LPSECURITY_ATTRIBUTES lpTokenAttributes,
3053 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
3054 TOKEN_TYPE TokenType,
3055 PHANDLE DuplicateTokenHandle )
3056 {
3057 OBJECT_ATTRIBUTES ObjectAttributes;
3058
3059 TRACE("%p 0x%08lx 0x%08x 0x%08x %p\n", ExistingTokenHandle, dwDesiredAccess,
3060 ImpersonationLevel, TokenType, DuplicateTokenHandle);
3061
3062 InitializeObjectAttributes(
3063 &ObjectAttributes,
3064 NULL,
3065 (lpTokenAttributes && lpTokenAttributes->bInheritHandle) ? OBJ_INHERIT : 0,
3066 NULL,
3067 lpTokenAttributes ? lpTokenAttributes->lpSecurityDescriptor : NULL );
3068
3069 return set_ntstatus( NtDuplicateToken( ExistingTokenHandle,
3070 dwDesiredAccess,
3071 &ObjectAttributes,
3072 ImpersonationLevel,
3073 TokenType,
3074 DuplicateTokenHandle ) );
3075 }
3076
3077 BOOL WINAPI DuplicateToken(
3078 HANDLE ExistingTokenHandle,
3079 SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
3080 PHANDLE DuplicateTokenHandle )
3081 {
3082 return DuplicateTokenEx( ExistingTokenHandle, TOKEN_IMPERSONATE | TOKEN_QUERY,
3083 NULL, ImpersonationLevel, TokenImpersonation,
3084 DuplicateTokenHandle );
3085 }
3086
3087 BOOL WINAPI EnumDependentServicesA(
3088 SC_HANDLE hService,
3089 DWORD dwServiceState,
3090 LPENUM_SERVICE_STATUSA lpServices,
3091 DWORD cbBufSize,
3092 LPDWORD pcbBytesNeeded,
3093 LPDWORD lpServicesReturned )
3094 {
3095 FIXME("%p 0x%08lx %p 0x%08lx %p %p - stub\n", hService, dwServiceState,
3096 lpServices, cbBufSize, pcbBytesNeeded, lpServicesReturned);
3097
3098 return FALSE;
3099 }
3100
3101 BOOL WINAPI EnumDependentServicesW(
3102 SC_HANDLE hService,
3103 DWORD dwServiceState,
3104 LPENUM_SERVICE_STATUSW lpServices,
3105 DWORD cbBufSize,
3106 LPDWORD pcbBytesNeeded,
3107 LPDWORD lpServicesReturned )
3108 {
3109 FIXME("%p 0x%08lx %p 0x%08lx %p %p - stub\n", hService, dwServiceState,
3110 lpServices, cbBufSize, pcbBytesNeeded, lpServicesReturned);
3111
3112 return FALSE;
3113 }
3114
3115 /******************************************************************************
3116 * ParseStringSidToSid
3117 */
3118 static BOOL ParseStringSidToSid(LPCWSTR StringSid, PSID pSid, LPDWORD cBytes)
3119 {
3120 BOOL bret = FALSE;
3121 SID* pisid=pSid;
3122
3123 TRACE("%s, %p, %p\n", debugstr_w(StringSid), pSid, cBytes);
3124 if (!StringSid)
3125 {
3126 SetLastError(ERROR_INVALID_PARAMETER);
3127 TRACE("StringSid is NULL, returning FALSE\n");
3128 return FALSE;
3129 }
3130
3131 *cBytes = ComputeStringSidSize(StringSid);
3132 if (!pisid) /* Simply compute the size */
3133 {
3134 TRACE("only size requested, returning TRUE\n");
3135 return TRUE;
3136 }
3137
3138 if (StringSid[0] == 'S' && StringSid[1] == '-') /* S-R-I-S-S */
3139 {
3140 DWORD i = 0, identAuth;
3141 DWORD csubauth = ((*cBytes - sizeof(SID)) / sizeof(DWORD)) + 1;
3142
3143 StringSid += 2; /* Advance to Revision */
3144 pisid->Revision = atoiW(StringSid);
3145
3146 if (pisid->Revision != SDDL_REVISION)
3147 {
3148 TRACE("Revision %d is unknown\n", pisid->Revision);
3149 goto lend; /* ERROR_INVALID_SID */
3150 }
3151 if (csubauth == 0)
3152 {
3153 TRACE("SubAuthorityCount is 0\n");
3154 goto lend; /* ERROR_INVALID_SID */
3155 }
3156
3157 pisid->SubAuthorityCount = csubauth;
3158
3159 /* Advance to identifier authority */
3160 while (*StringSid && *StringSid != '-')
3161 StringSid++;
3162 if (*StringSid == '-')
3163 StringSid++;
3164
3165 /* MS' implementation can't handle values greater than 2^32 - 1, so
3166 * we don't either; assume most significant bytes are always 0
3167 */
3168 pisid->IdentifierAuthority.Value[0] = 0;
3169 pisid->IdentifierAuthority.Value[1] = 0;
3170 identAuth = atoiW(StringSid);
3171 pisid->IdentifierAuthority.Value[5] = identAuth & 0xff;
3172 pisid->IdentifierAuthority.Value[4] = (identAuth & 0xff00) >> 8;
3173 pisid->IdentifierAuthority.Value[3] = (identAuth & 0xff0000) >> 16;
3174 pisid->IdentifierAuthority.Value[2] = (identAuth & 0xff000000) >> 24;
3175
3176 /* Advance to first sub authority */
3177 while (*StringSid && *StringSid != '-')
3178 StringSid++;
3179 if (*StringSid == '-')
3180 StringSid++;
3181
3182 while (*StringSid)
3183 {
3184 while (*StringSid && *StringSid != '-')
3185 StringSid++;
3186
3187 pisid->SubAuthority[i++] = atoiW(StringSid);
3188 }
3189
3190 if (i != pisid->SubAuthorityCount)
3191 goto lend; /* ERROR_INVALID_SID */
3192
3193 bret = TRUE;
3194 }
3195 else /* String constant format - Only available in winxp and above */
3196 {
3197 pisid->Revision = SDDL_REVISION;
3198 pisid->SubAuthorityCount = 1;
3199
3200 FIXME("String constant not supported: %s\n", debugstr_wn(StringSid, 2));
3201
3202 /* TODO: Lookup string of well-known SIDs in table */
3203 pisid->IdentifierAuthority.Value[5] = 0;
3204 pisid->SubAuthority[0] = 0;
3205
3206 bret = TRUE;
3207 }
3208
3209 lend:
3210 if (!bret)
3211 SetLastError(ERROR_INVALID_SID);
3212
3213 TRACE("returning %s\n", bret ? "TRUE" : "FALSE");
3214 return bret;
3215 }
3216
3217 /******************************************************************************
3218 * GetNamedSecurityInfoA [ADVAPI32.@]
3219 */
3220 DWORD WINAPI GetNamedSecurityInfoA(LPSTR pObjectName,
3221 SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo,
3222 PSID* ppsidOwner, PSID* ppsidGroup, PACL* ppDacl, PACL* ppSacl,
3223 PSECURITY_DESCRIPTOR* ppSecurityDescriptor)
3224 {
3225 DWORD len;
3226 LPWSTR wstr = NULL;
3227 DWORD r;
3228
3229 TRACE("%s %d %ld %p %p %p %p %p\n", pObjectName, ObjectType, SecurityInfo,
3230 ppsidOwner, ppsidGroup, ppDacl, ppSacl, ppSecurityDescriptor);
3231
3232 if( pObjectName )
3233 {
3234 len = MultiByteToWideChar( CP_ACP, 0, pObjectName, -1, NULL, 0 );
3235 wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof(WCHAR));
3236 MultiByteToWideChar( CP_ACP, 0, pObjectName, -1, wstr, len );
3237 }
3238
3239 r = GetNamedSecurityInfoW( wstr, ObjectType, SecurityInfo, ppsidOwner,
3240 ppsidGroup, ppDacl, ppSacl, ppSecurityDescriptor );
3241
3242 HeapFree( GetProcessHeap(), 0, wstr );
3243
3244 return r;
3245 }
3246
3247 /******************************************************************************
3248 * GetNamedSecurityInfoW [ADVAPI32.@]
3249 */
3250 DWORD WINAPI GetNamedSecurityInfoW( LPWSTR name, SE_OBJECT_TYPE type,
3251 SECURITY_INFORMATION info, PSID* owner, PSID* group, PACL* dacl,
3252 PACL* sacl, PSECURITY_DESCRIPTOR* descriptor )
3253 {
3254 DWORD needed, offset;
3255 SECURITY_DESCRIPTOR_RELATIVE *relative;
3256 BYTE *buffer;
3257
3258 TRACE( "%s %d %ld %p %p %p %p %p\n", debugstr_w(name), type, info, owner,
3259 group, dacl, sacl, descriptor );
3260
3261 if (!name || !descriptor) return ERROR_INVALID_PARAMETER;
3262
3263 needed = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
3264 if (info & OWNER_SECURITY_INFORMATION)
3265 needed += sizeof(sidWorld);
3266 if (info & GROUP_SECURITY_INFORMATION)
3267 needed += sizeof(sidWorld);
3268 if (info & DACL_SECURITY_INFORMATION)
3269 needed += WINE_SIZE_OF_WORLD_ACCESS_ACL;
3270 if (info & SACL_SECURITY_INFORMATION)
3271 needed += WINE_SIZE_OF_WORLD_ACCESS_ACL;
3272
3273 /* must be freed by caller */
3274 *descriptor = HeapAlloc( GetProcessHeap(), 0, needed );
3275 if (!*descriptor) return ERROR_NOT_ENOUGH_MEMORY;
3276
3277 if (!InitializeSecurityDescriptor( *descriptor, SECURITY_DESCRIPTOR_REVISION ))
3278 {
3279 HeapFree( GetProcessHeap(), 0, *descriptor );
3280 return ERROR_INVALID_SECURITY_DESCR;
3281 }
3282
3283 relative = (SECURITY_DESCRIPTOR_RELATIVE *)*descriptor;
3284 relative->Control |= SE_SELF_RELATIVE;
3285 buffer = (BYTE *)relative;
3286 offset = sizeof(SECURITY_DESCRIPTOR_RELATIVE);
3287
3288 if (owner && (info & OWNER_SECURITY_INFORMATION))
3289 {
3290 memcpy( buffer + offset, &sidWorld, sizeof(sidWorld) );
3291 relative->Owner = offset;
3292 *owner = buffer + offset;
3293 offset += sizeof(sidWorld);
3294 }
3295 if (group && (info & GROUP_SECURITY_INFORMATION))
3296 {
3297 memcpy( buffer + offset, &sidWorld, sizeof(sidWorld) );
3298 relative->Group = offset;
3299 *group = buffer + offset;
3300 offset += sizeof(sidWorld);
3301 }
3302 if (dacl && (info & DACL_SECURITY_INFORMATION))
3303 {
3304 GetWorldAccessACL( (PACL)(buffer + offset) );
3305 relative->Dacl = offset;
3306 *dacl = (PACL)(buffer + offset);
3307 offset += WINE_SIZE_OF_WORLD_ACCESS_ACL;
3308 }
3309 if (sacl && (info & SACL_SECURITY_INFORMATION))
3310 {
3311 GetWorldAccessACL( (PACL)(buffer + offset) );
3312 relative->Sacl = offset;
3313 *sacl = (PACL)(buffer + offset);
3314 }
3315 return ERROR_SUCCESS;
3316 }
3317
3318 /******************************************************************************
3319 * DecryptFileW [ADVAPI32.@]
3320 */
3321 BOOL WINAPI DecryptFileW(LPCWSTR lpFileName, DWORD dwReserved)
3322 {
3323 FIXME("%s %08lx\n", debugstr_w(lpFileName), dwReserved);
3324 return TRUE;
3325 }
3326
3327 /******************************************************************************
3328 * DecryptFileA [ADVAPI32.@]
3329 */
3330 BOOL WINAPI DecryptFileA(LPCSTR lpFileName, DWORD dwReserved)
3331 {
3332 FIXME("%s %08lx\n", debugstr_a(lpFileName), dwReserved);
3333 return TRUE;
3334 }
3335
3336 /******************************************************************************
3337 * EncryptFileW [ADVAPI32.@]
3338 */
3339 BOOL WINAPI EncryptFileW(LPCWSTR lpFileName)
3340 {
3341 FIXME("%s\n", debugstr_w(lpFileName));
3342 return TRUE;
3343 }
3344
3345 /******************************************************************************
3346 * EncryptFileA [ADVAPI32.@]
3347 */
3348 BOOL WINAPI EncryptFileA(LPCSTR lpFileName)
3349 {
3350 FIXME("%s\n", debugstr_a(lpFileName));
3351 return TRUE;
3352 }
3353
3354 /******************************************************************************
3355 * SetSecurityInfo [ADVAPI32.@]
3356 */
3357 DWORD WINAPI SetSecurityInfo(HANDLE handle, SE_OBJECT_TYPE ObjectType,
3358 SECURITY_INFORMATION SecurityInfo, PSID psidOwner,
3359 PSID psidGroup, PACL pDacl, PACL pSacl) {
3360 FIXME("stub\n");
3361 return ERROR_SUCCESS;
3362 }
GSOC 2012 project to enhance the control panel