Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 06:52:56 +00:00
Code Issues Projects Releases Packages Wiki Activity

[FORMATTING] No code changes!

Browse source 
svn path=/trunk/; revision=36377
This commit is contained in:
Eric Kohl 2008-09-21 13:55:53 +00:00
parent fff44b9cb5
commit b48aef5119
9 changed files with 2116 additions and 2086 deletions
Download patch file Download diff file Expand all files Collapse all files

628
reactos/dll/win32/advapi32/sec/ac.c
View file

@ -18,26 +18,24 @@ WINE_DEFAULT_DEBUG_CHANNEL(advapi);
*/ */
BOOL BOOL
STDCALL STDCALL
GetAclInformation ( GetAclInformation(PACL pAcl,
PACL pAcl, LPVOID pAclInformation,
LPVOID pAclInformation, DWORD nAclInformationLength,
DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass)
ACL_INFORMATION_CLASS dwAclInformationClass
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlQueryInformationAcl (pAcl, Status = RtlQueryInformationAcl(pAcl,
pAclInformation, pAclInformation,
nAclInformationLength, nAclInformationLength,
dwAclInformationClass); dwAclInformationClass);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -46,24 +44,22 @@ GetAclInformation (
*/ */
BOOL BOOL
STDCALL STDCALL
InitializeAcl ( InitializeAcl(PACL pAcl,
PACL pAcl, DWORD nAclLength,
DWORD nAclLength, DWORD dwAclRevision)
DWORD dwAclRevision
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlCreateAcl (pAcl, Status = RtlCreateAcl(pAcl,
nAclLength, nAclLength,
dwAclRevision); dwAclRevision);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -72,11 +68,9 @@ InitializeAcl (
*/ */
BOOL BOOL
STDCALL STDCALL
IsValidAcl ( IsValidAcl(PACL pAcl)
PACL pAcl
)
{ {
return RtlValidAcl (pAcl); return RtlValidAcl (pAcl);
} }
@ -85,26 +79,24 @@ IsValidAcl (
*/ */
BOOL BOOL
STDCALL STDCALL
SetAclInformation ( SetAclInformation(PACL pAcl,
PACL pAcl, LPVOID pAclInformation,
LPVOID pAclInformation, DWORD nAclInformationLength,
DWORD nAclInformationLength, ACL_INFORMATION_CLASS dwAclInformationClass)
ACL_INFORMATION_CLASS dwAclInformationClass
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlSetInformationAcl (pAcl, Status = RtlSetInformationAcl(pAcl,
pAclInformation, pAclInformation,
nAclInformationLength, nAclInformationLength,
dwAclInformationClass); dwAclInformationClass);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -115,26 +107,24 @@ SetAclInformation (
*/ */
BOOL BOOL
STDCALL STDCALL
AddAccessAllowedAce ( AddAccessAllowedAce(PACL pAcl,
PACL pAcl, DWORD dwAceRevision,
DWORD dwAceRevision, DWORD AccessMask,
DWORD AccessMask, PSID pSid)
PSID pSid
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlAddAccessAllowedAce (pAcl, Status = RtlAddAccessAllowedAce(pAcl,
dwAceRevision, dwAceRevision,
AccessMask, AccessMask,
pSid); pSid);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -143,25 +133,25 @@ AddAccessAllowedAce (
*/ */
BOOL STDCALL BOOL STDCALL
AddAccessAllowedAceEx(PACL pAcl, AddAccessAllowedAceEx(PACL pAcl,
DWORD dwAceRevision, DWORD dwAceRevision,
DWORD AceFlags, DWORD AceFlags,
DWORD AccessMask, DWORD AccessMask,
PSID pSid) PSID pSid)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlAddAccessAllowedAceEx(pAcl, Status = RtlAddAccessAllowedAceEx(pAcl,
dwAceRevision, dwAceRevision,
AceFlags, AceFlags,
AccessMask, AccessMask,
pSid); pSid);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -170,31 +160,30 @@ AddAccessAllowedAceEx(PACL pAcl,
*/ */
BOOL BOOL
STDCALL STDCALL
AddAccessAllowedObjectAce( AddAccessAllowedObjectAce(PACL pAcl,
PACL pAcl, DWORD dwAceRevision,
DWORD dwAceRevision, DWORD AceFlags,
DWORD AceFlags, DWORD AccessMask,
DWORD AccessMask, GUID *ObjectTypeGuid,
GUID* ObjectTypeGuid, GUID *InheritedObjectTypeGuid,
GUID* InheritedObjectTypeGuid, PSID pSid)
PSID pSid)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlAddAccessAllowedObjectAce(pAcl, Status = RtlAddAccessAllowedObjectAce(pAcl,
dwAceRevision, dwAceRevision,
AceFlags, AceFlags,
AccessMask, AccessMask,
ObjectTypeGuid, ObjectTypeGuid,
InheritedObjectTypeGuid, InheritedObjectTypeGuid,
pSid); pSid);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -203,26 +192,24 @@ AddAccessAllowedObjectAce(
*/ */
BOOL BOOL
STDCALL STDCALL
AddAccessDeniedAce ( AddAccessDeniedAce(PACL pAcl,
PACL pAcl, DWORD dwAceRevision,
DWORD dwAceRevision, DWORD AccessMask,
DWORD AccessMask, PSID pSid)
PSID pSid
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlAddAccessDeniedAce (pAcl, Status = RtlAddAccessDeniedAce(pAcl,
dwAceRevision, dwAceRevision,
AccessMask, AccessMask,
pSid); pSid);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -231,25 +218,25 @@ AddAccessDeniedAce (
*/ */
BOOL STDCALL BOOL STDCALL
AddAccessDeniedAceEx(PACL pAcl, AddAccessDeniedAceEx(PACL pAcl,
DWORD dwAceRevision, DWORD dwAceRevision,
DWORD AceFlags, DWORD AceFlags,
DWORD AccessMask, DWORD AccessMask,
PSID pSid) PSID pSid)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlAddAccessDeniedAceEx(pAcl, Status = RtlAddAccessDeniedAceEx(pAcl,
dwAceRevision, dwAceRevision,
AceFlags, AceFlags,
AccessMask, AccessMask,
pSid); pSid);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -258,31 +245,30 @@ AddAccessDeniedAceEx(PACL pAcl,
*/ */
BOOL BOOL
STDCALL STDCALL
AddAccessDeniedObjectAce( AddAccessDeniedObjectAce(PACL pAcl,
PACL pAcl, DWORD dwAceRevision,
DWORD dwAceRevision, DWORD AceFlags,
DWORD AceFlags, DWORD AccessMask,
DWORD AccessMask, GUID* ObjectTypeGuid,
GUID* ObjectTypeGuid, GUID* InheritedObjectTypeGuid,
GUID* InheritedObjectTypeGuid, PSID pSid)
PSID pSid)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlAddAccessDeniedObjectAce(pAcl, Status = RtlAddAccessDeniedObjectAce(pAcl,
dwAceRevision, dwAceRevision,
AceFlags, AceFlags,
AccessMask, AccessMask,
ObjectTypeGuid, ObjectTypeGuid,
InheritedObjectTypeGuid, InheritedObjectTypeGuid,
pSid); pSid);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -291,28 +277,26 @@ AddAccessDeniedObjectAce(
*/ */
BOOL BOOL
STDCALL STDCALL
AddAce ( AddAce(PACL pAcl,
PACL pAcl, DWORD dwAceRevision,
DWORD dwAceRevision, DWORD dwStartingAceIndex,
DWORD dwStartingAceIndex, LPVOID pAceList,
LPVOID pAceList, DWORD nAceListLength)
DWORD nAceListLength
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlAddAce (pAcl, Status = RtlAddAce(pAcl,
dwAceRevision, dwAceRevision,
dwStartingAceIndex, dwStartingAceIndex,
pAceList, pAceList,
nAceListLength); nAceListLength);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -321,30 +305,28 @@ AddAce (
*/ */
BOOL BOOL
STDCALL STDCALL
AddAuditAccessAce ( AddAuditAccessAce(PACL pAcl,
PACL pAcl, DWORD dwAceRevision,
DWORD dwAceRevision, DWORD dwAccessMask,
DWORD dwAccessMask, PSID pSid,
PSID pSid, BOOL bAuditSuccess,
BOOL bAuditSuccess, BOOL bAuditFailure)
BOOL bAuditFailure
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlAddAuditAccessAce (pAcl, Status = RtlAddAuditAccessAce(pAcl,
dwAceRevision, dwAceRevision,
dwAccessMask, dwAccessMask,
pSid, pSid,
bAuditSuccess, bAuditSuccess,
bAuditFailure); bAuditFailure);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -353,29 +335,29 @@ AddAuditAccessAce (
*/ */
BOOL STDCALL BOOL STDCALL
AddAuditAccessAceEx(PACL pAcl, AddAuditAccessAceEx(PACL pAcl,
DWORD dwAceRevision, DWORD dwAceRevision,
DWORD AceFlags, DWORD AceFlags,
DWORD dwAccessMask, DWORD dwAccessMask,
PSID pSid, PSID pSid,
BOOL bAuditSuccess, BOOL bAuditSuccess,
BOOL bAuditFailure) BOOL bAuditFailure)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlAddAuditAccessAceEx(pAcl, Status = RtlAddAuditAccessAceEx(pAcl,
dwAceRevision, dwAceRevision,
AceFlags, AceFlags,
dwAccessMask, dwAccessMask,
pSid, pSid,
bAuditSuccess, bAuditSuccess,
bAuditFailure); bAuditFailure);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -384,35 +366,34 @@ AddAuditAccessAceEx(PACL pAcl,
*/ */
BOOL BOOL
STDCALL STDCALL
AddAuditAccessObjectAce( AddAuditAccessObjectAce(PACL pAcl,
PACL pAcl, DWORD dwAceRevision,
DWORD dwAceRevision, DWORD AceFlags,
DWORD AceFlags, DWORD AccessMask,
DWORD AccessMask, GUID *ObjectTypeGuid,
GUID* ObjectTypeGuid, GUID *InheritedObjectTypeGuid,
GUID* InheritedObjectTypeGuid, PSID pSid,
PSID pSid, BOOL bAuditSuccess,
BOOL bAuditSuccess, BOOL bAuditFailure)
BOOL bAuditFailure)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlAddAuditAccessObjectAce(pAcl, Status = RtlAddAuditAccessObjectAce(pAcl,
dwAceRevision, dwAceRevision,
AceFlags, AceFlags,
AccessMask, AccessMask,
ObjectTypeGuid, ObjectTypeGuid,
InheritedObjectTypeGuid, InheritedObjectTypeGuid,
pSid, pSid,
bAuditSuccess, bAuditSuccess,
bAuditFailure); bAuditFailure);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -450,22 +431,20 @@ AddMandatoryAce(IN OUT PACL pAcl,
*/ */
BOOL BOOL
STDCALL STDCALL
DeleteAce ( DeleteAce(PACL pAcl,
PACL pAcl, DWORD dwAceIndex)
DWORD dwAceIndex
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlDeleteAce (pAcl, Status = RtlDeleteAce(pAcl,
dwAceIndex); dwAceIndex);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -474,13 +453,11 @@ DeleteAce (
*/ */
BOOL BOOL
STDCALL STDCALL
FindFirstFreeAce ( FindFirstFreeAce(PACL pAcl,
PACL pAcl, LPVOID *pAce)
LPVOID * pAce
)
{ {
return RtlFirstFreeAce (pAcl, return RtlFirstFreeAce(pAcl,
(PACE*)pAce); (PACE*)pAce);
} }
@ -489,24 +466,22 @@ FindFirstFreeAce (
*/ */
BOOL BOOL
STDCALL STDCALL
GetAce ( GetAce(PACL pAcl,
PACL pAcl, DWORD dwAceIndex,
DWORD dwAceIndex, LPVOID *pAce)
LPVOID * pAce
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlGetAce (pAcl, Status = RtlGetAce(pAcl,
dwAceIndex, dwAceIndex,
pAce); pAce);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -515,18 +490,16 @@ GetAce (
*/ */
DWORD DWORD
STDCALL STDCALL
GetInheritanceSourceW ( GetInheritanceSourceW(LPWSTR pObjectName,
LPWSTR pObjectName, SE_OBJECT_TYPE ObjectType,
SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo,
SECURITY_INFORMATION SecurityInfo, BOOL Container,
BOOL Container, GUID **pObjectClassGuids OPTIONAL,
GUID** pObjectClassGuids OPTIONAL, DWORD GuidCount,
DWORD GuidCount, PACL pAcl,
PACL pAcl, PFN_OBJECT_MGR_FUNCTS pfnArray OPTIONAL,
PFN_OBJECT_MGR_FUNCTS pfnArray OPTIONAL, PGENERIC_MAPPING pGenericMapping,
PGENERIC_MAPPING pGenericMapping, PINHERITED_FROMW pInheritArray)
PINHERITED_FROMW pInheritArray
)
{ {
DWORD ErrorCode; DWORD ErrorCode;
@ -555,18 +528,16 @@ GetInheritanceSourceW (
*/ */
DWORD DWORD
STDCALL STDCALL
GetInheritanceSourceA ( GetInheritanceSourceA(LPSTR pObjectName,
LPSTR pObjectName, SE_OBJECT_TYPE ObjectType,
SE_OBJECT_TYPE ObjectType, SECURITY_INFORMATION SecurityInfo,
SECURITY_INFORMATION SecurityInfo, BOOL Container,
BOOL Container, GUID **pObjectClassGuids OPTIONAL,
GUID** pObjectClassGuids OPTIONAL, DWORD GuidCount,
DWORD GuidCount, PACL pAcl,
PACL pAcl, PFN_OBJECT_MGR_FUNCTS pfnArray OPTIONAL,
PFN_OBJECT_MGR_FUNCTS pfnArray OPTIONAL, PGENERIC_MAPPING pGenericMapping,
PGENERIC_MAPPING pGenericMapping, PINHERITED_FROMA pInheritArray)
PINHERITED_FROMA pInheritArray
)
{ {
/* That's all this function does, at least up to w2k3... Even MS was too /* That's all this function does, at least up to w2k3... Even MS was too
lazy to implement it... */ lazy to implement it... */
@ -579,11 +550,9 @@ GetInheritanceSourceA (
*/ */
DWORD DWORD
STDCALL STDCALL
FreeInheritedFromArray ( FreeInheritedFromArray(PINHERITED_FROMW pInheritArray,
PINHERITED_FROMW pInheritArray, USHORT AceCnt,
USHORT AceCnt, PFN_OBJECT_MGR_FUNCTS pfnArray OPTIONAL)
PFN_OBJECT_MGR_FUNCTS pfnArray OPTIONAL
)
{ {
DWORD ErrorCode; DWORD ErrorCode;
@ -605,11 +574,10 @@ FreeInheritedFromArray (
*/ */
DWORD DWORD
STDCALL STDCALL
SetEntriesInAclW( SetEntriesInAclW(ULONG cCountOfExplicitEntries,
ULONG cCountOfExplicitEntries, PEXPLICIT_ACCESS_W pListOfExplicitEntries,
PEXPLICIT_ACCESS_W pListOfExplicitEntries, PACL OldAcl,
PACL OldAcl, PACL *NewAcl)
PACL* NewAcl)
{ {
DWORD ErrorCode; DWORD ErrorCode;
@ -1013,11 +981,10 @@ RawTrusteeCopy:
*/ */
DWORD DWORD
STDCALL STDCALL
SetEntriesInAclA( SetEntriesInAclA(ULONG cCountOfExplicitEntries,
ULONG cCountOfExplicitEntries, PEXPLICIT_ACCESS_A pListOfExplicitEntries,
PEXPLICIT_ACCESS_A pListOfExplicitEntries, PACL OldAcl,
PACL OldAcl, PACL *NewAcl)
PACL* NewAcl)
{ {
PEXPLICIT_ACCESS_W ListOfExplicitEntriesW = NULL; PEXPLICIT_ACCESS_W ListOfExplicitEntriesW = NULL;
DWORD ErrorCode; DWORD ErrorCode;
@ -1025,7 +992,6 @@ SetEntriesInAclA(
ErrorCode = InternalExplicitAccessAToW(cCountOfExplicitEntries, ErrorCode = InternalExplicitAccessAToW(cCountOfExplicitEntries,
pListOfExplicitEntries, pListOfExplicitEntries,
&ListOfExplicitEntriesW); &ListOfExplicitEntriesW);
if (ErrorCode == ERROR_SUCCESS) if (ErrorCode == ERROR_SUCCESS)
{ {
ErrorCode = SetEntriesInAclW(cCountOfExplicitEntries, ErrorCode = SetEntriesInAclW(cCountOfExplicitEntries,
@ -1048,11 +1014,9 @@ SetEntriesInAclA(
*/ */
DWORD DWORD
STDCALL STDCALL
GetExplicitEntriesFromAclW( GetExplicitEntriesFromAclW(PACL pacl,
PACL pacl, PULONG pcCountOfExplicitEntries,
PULONG pcCountOfExplicitEntries, PEXPLICIT_ACCESS_W *pListOfExplicitEntries)
PEXPLICIT_ACCESS_W* pListOfExplicitEntries
)
{ {
DWORD ErrorCode; DWORD ErrorCode;
@ -1078,8 +1042,8 @@ GetEffectiveRightsFromAclW(IN PACL pacl,
IN PTRUSTEE_W pTrustee, IN PTRUSTEE_W pTrustee,
OUT PACCESS_MASK pAccessRights) OUT PACCESS_MASK pAccessRights)
{ {
FIXME("%s() not implemented!\n", __FUNCTION__); FIXME("%s() not implemented!\n", __FUNCTION__);
return ERROR_CALL_NOT_IMPLEMENTED; return ERROR_CALL_NOT_IMPLEMENTED;
} }
@ -1123,8 +1087,8 @@ GetAuditedPermissionsFromAclW(IN PACL pacl,
OUT PACCESS_MASK pSuccessfulAuditedRights, OUT PACCESS_MASK pSuccessfulAuditedRights,
OUT PACCESS_MASK pFailedAuditRights) OUT PACCESS_MASK pFailedAuditRights)
{ {
FIXME("%s() not implemented!\n", __FUNCTION__); FIXME("%s() not implemented!\n", __FUNCTION__);
return ERROR_CALL_NOT_IMPLEMENTED; return ERROR_CALL_NOT_IMPLEMENTED;
} }

708
reactos/dll/win32/advapi32/sec/audit.c
View file

@ -22,65 +22,65 @@ WINE_DEFAULT_DEBUG_CHANNEL(advapi);
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
AccessCheckAndAuditAlarmA (LPCSTR SubsystemName, AccessCheckAndAuditAlarmA(LPCSTR SubsystemName,
LPVOID HandleId, LPVOID HandleId,
LPSTR ObjectTypeName, LPSTR ObjectTypeName,
LPSTR ObjectName, LPSTR ObjectName,
PSECURITY_DESCRIPTOR SecurityDescriptor, PSECURITY_DESCRIPTOR SecurityDescriptor,
DWORD DesiredAccess, DWORD DesiredAccess,
PGENERIC_MAPPING GenericMapping, PGENERIC_MAPPING GenericMapping,
BOOL ObjectCreation, BOOL ObjectCreation,
LPDWORD GrantedAccess, LPDWORD GrantedAccess,
LPBOOL AccessStatus, LPBOOL AccessStatus,
LPBOOL pfGenerateOnClose) LPBOOL pfGenerateOnClose)
{ {
UNICODE_STRING SubsystemNameU; UNICODE_STRING SubsystemNameU;
UNICODE_STRING ObjectTypeNameU; UNICODE_STRING ObjectTypeNameU;
UNICODE_STRING ObjectNameU; UNICODE_STRING ObjectNameU;
NTSTATUS LocalAccessStatus; NTSTATUS LocalAccessStatus;
BOOLEAN GenerateOnClose; BOOLEAN GenerateOnClose;
NTSTATUS Status; NTSTATUS Status;
RtlCreateUnicodeStringFromAsciiz (&SubsystemNameU, RtlCreateUnicodeStringFromAsciiz(&SubsystemNameU,
(PCHAR)SubsystemName); (PCHAR)SubsystemName);
RtlCreateUnicodeStringFromAsciiz (&ObjectTypeNameU, RtlCreateUnicodeStringFromAsciiz(&ObjectTypeNameU,
(PCHAR)ObjectTypeName); (PCHAR)ObjectTypeName);
RtlCreateUnicodeStringFromAsciiz (&ObjectNameU, RtlCreateUnicodeStringFromAsciiz(&ObjectNameU,
(PCHAR)ObjectName); (PCHAR)ObjectName);
Status = NtAccessCheckAndAuditAlarm (&SubsystemNameU, Status = NtAccessCheckAndAuditAlarm(&SubsystemNameU,
HandleId, HandleId,
&ObjectTypeNameU, &ObjectTypeNameU,
&ObjectNameU, &ObjectNameU,
SecurityDescriptor, SecurityDescriptor,
DesiredAccess, DesiredAccess,
GenericMapping, GenericMapping,
ObjectCreation, ObjectCreation,
GrantedAccess, GrantedAccess,
&LocalAccessStatus, &LocalAccessStatus,
&GenerateOnClose); &GenerateOnClose);
RtlFreeUnicodeString (&SubsystemNameU); RtlFreeUnicodeString(&SubsystemNameU);
RtlFreeUnicodeString (&ObjectTypeNameU); RtlFreeUnicodeString(&ObjectTypeNameU);
RtlFreeUnicodeString (&ObjectNameU); RtlFreeUnicodeString(&ObjectNameU);
*pfGenerateOnClose = (BOOL)GenerateOnClose; *pfGenerateOnClose = (BOOL)GenerateOnClose;
if (!NT_SUCCESS (Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
if (!NT_SUCCESS (LocalAccessStatus)) if (!NT_SUCCESS (LocalAccessStatus))
{ {
*AccessStatus = FALSE; *AccessStatus = FALSE;
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
*AccessStatus = TRUE; *AccessStatus = TRUE;
return TRUE; return TRUE;
} }
@ -88,62 +88,62 @@ AccessCheckAndAuditAlarmA (LPCSTR SubsystemName,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
AccessCheckAndAuditAlarmW (LPCWSTR SubsystemName, AccessCheckAndAuditAlarmW(LPCWSTR SubsystemName,
LPVOID HandleId, LPVOID HandleId,
LPWSTR ObjectTypeName, LPWSTR ObjectTypeName,
LPWSTR ObjectName, LPWSTR ObjectName,
PSECURITY_DESCRIPTOR SecurityDescriptor, PSECURITY_DESCRIPTOR SecurityDescriptor,
DWORD DesiredAccess, DWORD DesiredAccess,
PGENERIC_MAPPING GenericMapping, PGENERIC_MAPPING GenericMapping,
BOOL ObjectCreation, BOOL ObjectCreation,
LPDWORD GrantedAccess, LPDWORD GrantedAccess,
LPBOOL AccessStatus, LPBOOL AccessStatus,
LPBOOL pfGenerateOnClose) LPBOOL pfGenerateOnClose)
{ {
UNICODE_STRING SubsystemNameU; UNICODE_STRING SubsystemNameU;
UNICODE_STRING ObjectTypeNameU; UNICODE_STRING ObjectTypeNameU;
UNICODE_STRING ObjectNameU; UNICODE_STRING ObjectNameU;
NTSTATUS LocalAccessStatus; NTSTATUS LocalAccessStatus;
BOOLEAN GenerateOnClose; BOOLEAN GenerateOnClose;
NTSTATUS Status; NTSTATUS Status;
RtlInitUnicodeString (&SubsystemNameU, RtlInitUnicodeString(&SubsystemNameU,
(PWSTR)SubsystemName); (PWSTR)SubsystemName);
RtlInitUnicodeString (&ObjectTypeNameU, RtlInitUnicodeString(&ObjectTypeNameU,
(PWSTR)ObjectTypeName); (PWSTR)ObjectTypeName);
RtlInitUnicodeString (&ObjectNameU, RtlInitUnicodeString(&ObjectNameU,
(PWSTR)ObjectName); (PWSTR)ObjectName);
Status = NtAccessCheckAndAuditAlarm (&SubsystemNameU, Status = NtAccessCheckAndAuditAlarm(&SubsystemNameU,
HandleId, HandleId,
&ObjectTypeNameU, &ObjectTypeNameU,
&ObjectNameU, &ObjectNameU,
SecurityDescriptor, SecurityDescriptor,
DesiredAccess, DesiredAccess,
GenericMapping, GenericMapping,
ObjectCreation, ObjectCreation,
GrantedAccess, GrantedAccess,
&LocalAccessStatus, &LocalAccessStatus,
&GenerateOnClose); &GenerateOnClose);
*pfGenerateOnClose = (BOOL)GenerateOnClose; *pfGenerateOnClose = (BOOL)GenerateOnClose;
if (!NT_SUCCESS (Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
if (!NT_SUCCESS (LocalAccessStatus)) if (!NT_SUCCESS(LocalAccessStatus))
{ {
*AccessStatus = FALSE; *AccessStatus = FALSE;
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
*AccessStatus = TRUE; *AccessStatus = TRUE;
return TRUE; return TRUE;
} }
@ -151,58 +151,32 @@ AccessCheckAndAuditAlarmW (LPCWSTR SubsystemName,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
ObjectCloseAuditAlarmA (LPCSTR SubsystemName, ObjectCloseAuditAlarmA(LPCSTR SubsystemName,
LPVOID HandleId, LPVOID HandleId,
BOOL GenerateOnClose) BOOL GenerateOnClose)
{ {
UNICODE_STRING Name; UNICODE_STRING Name;
NTSTATUS Status; NTSTATUS Status;
Status = RtlCreateUnicodeStringFromAsciiz (&Name, Status = RtlCreateUnicodeStringFromAsciiz(&Name,
(PCHAR)SubsystemName); (PCHAR)SubsystemName);
if (!NT_SUCCESS (Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
Status = NtCloseObjectAuditAlarm (&Name, Status = NtCloseObjectAuditAlarm(&Name,
HandleId, HandleId,
GenerateOnClose); GenerateOnClose);
RtlFreeUnicodeString(&Name); RtlFreeUnicodeString(&Name);
if (!NT_SUCCESS (Status)) if (!NT_SUCCESS (Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
}
/*
* @implemented
*/
BOOL STDCALL
ObjectCloseAuditAlarmW (LPCWSTR SubsystemName,
LPVOID HandleId,
BOOL GenerateOnClose)
{
UNICODE_STRING Name;
NTSTATUS Status;
RtlInitUnicodeString (&Name,
(PWSTR)SubsystemName);
Status = NtCloseObjectAuditAlarm (&Name,
HandleId,
GenerateOnClose);
if (!NT_SUCCESS (Status))
{
SetLastError (RtlNtStatusToDosError (Status));
return FALSE;
}
return TRUE;
} }
@ -210,32 +184,26 @@ ObjectCloseAuditAlarmW (LPCWSTR SubsystemName,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
ObjectDeleteAuditAlarmA (LPCSTR SubsystemName, ObjectCloseAuditAlarmW(LPCWSTR SubsystemName,
LPVOID HandleId, LPVOID HandleId,
BOOL GenerateOnClose) BOOL GenerateOnClose)
{ {
UNICODE_STRING Name; UNICODE_STRING Name;
NTSTATUS Status; NTSTATUS Status;
Status = RtlCreateUnicodeStringFromAsciiz (&Name, RtlInitUnicodeString(&Name,
(PCHAR)SubsystemName); (PWSTR)SubsystemName);
if (!NT_SUCCESS (Status))
Status = NtCloseObjectAuditAlarm(&Name,
HandleId,
GenerateOnClose);
if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
Status = NtDeleteObjectAuditAlarm (&Name, return TRUE;
HandleId,
GenerateOnClose);
RtlFreeUnicodeString(&Name);
if (!NT_SUCCESS (Status))
{
SetLastError (RtlNtStatusToDosError (Status));
return FALSE;
}
return TRUE;
} }
@ -243,26 +211,32 @@ ObjectDeleteAuditAlarmA (LPCSTR SubsystemName,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
ObjectDeleteAuditAlarmW (LPCWSTR SubsystemName, ObjectDeleteAuditAlarmA(LPCSTR SubsystemName,
LPVOID HandleId, LPVOID HandleId,
BOOL GenerateOnClose) BOOL GenerateOnClose)
{ {
UNICODE_STRING Name; UNICODE_STRING Name;
NTSTATUS Status; NTSTATUS Status;
RtlInitUnicodeString (&Name, Status = RtlCreateUnicodeStringFromAsciiz(&Name,
(PWSTR)SubsystemName); (PCHAR)SubsystemName);
if (!NT_SUCCESS(Status))
Status = NtDeleteObjectAuditAlarm (&Name,
HandleId,
GenerateOnClose);
if (!NT_SUCCESS (Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; Status = NtDeleteObjectAuditAlarm(&Name,
HandleId,
GenerateOnClose);
RtlFreeUnicodeString(&Name);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
}
return TRUE;
} }
@ -270,53 +244,26 @@ ObjectDeleteAuditAlarmW (LPCWSTR SubsystemName,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
ObjectOpenAuditAlarmA (LPCSTR SubsystemName, ObjectDeleteAuditAlarmW(LPCWSTR SubsystemName,
LPVOID HandleId, LPVOID HandleId,
LPSTR ObjectTypeName, BOOL GenerateOnClose)
LPSTR ObjectName,
PSECURITY_DESCRIPTOR pSecurityDescriptor,
HANDLE ClientToken,
DWORD DesiredAccess,
DWORD GrantedAccess,
PPRIVILEGE_SET Privileges,
BOOL ObjectCreation,
BOOL AccessGranted,
LPBOOL GenerateOnClose)
{ {
UNICODE_STRING SubsystemNameU; UNICODE_STRING Name;
UNICODE_STRING ObjectTypeNameU; NTSTATUS Status;
UNICODE_STRING ObjectNameU;
NTSTATUS Status;
RtlCreateUnicodeStringFromAsciiz (&SubsystemNameU, RtlInitUnicodeString(&Name,
(PCHAR)SubsystemName); (PWSTR)SubsystemName);
RtlCreateUnicodeStringFromAsciiz (&ObjectTypeNameU,
(PCHAR)ObjectTypeName);
RtlCreateUnicodeStringFromAsciiz (&ObjectNameU,
(PCHAR)ObjectName);
Status = NtOpenObjectAuditAlarm (&SubsystemNameU, Status = NtDeleteObjectAuditAlarm(&Name,
HandleId, HandleId,
&ObjectTypeNameU, GenerateOnClose);
&ObjectNameU, if (!NT_SUCCESS(Status))
pSecurityDescriptor,
ClientToken,
DesiredAccess,
GrantedAccess,
Privileges,
ObjectCreation,
AccessGranted,
(PBOOLEAN)GenerateOnClose);
RtlFreeUnicodeString (&SubsystemNameU);
RtlFreeUnicodeString (&ObjectTypeNameU);
RtlFreeUnicodeString (&ObjectNameU);
if (!NT_SUCCESS (Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -324,50 +271,53 @@ ObjectOpenAuditAlarmA (LPCSTR SubsystemName,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
ObjectOpenAuditAlarmW (LPCWSTR SubsystemName, ObjectOpenAuditAlarmA(LPCSTR SubsystemName,
LPVOID HandleId, LPVOID HandleId,
LPWSTR ObjectTypeName, LPSTR ObjectTypeName,
LPWSTR ObjectName, LPSTR ObjectName,
PSECURITY_DESCRIPTOR pSecurityDescriptor, PSECURITY_DESCRIPTOR pSecurityDescriptor,
HANDLE ClientToken, HANDLE ClientToken,
DWORD DesiredAccess, DWORD DesiredAccess,
DWORD GrantedAccess, DWORD GrantedAccess,
PPRIVILEGE_SET Privileges, PPRIVILEGE_SET Privileges,
BOOL ObjectCreation, BOOL ObjectCreation,
BOOL AccessGranted, BOOL AccessGranted,
LPBOOL GenerateOnClose) LPBOOL GenerateOnClose)
{ {
UNICODE_STRING SubsystemNameU; UNICODE_STRING SubsystemNameU;
UNICODE_STRING ObjectTypeNameU; UNICODE_STRING ObjectTypeNameU;
UNICODE_STRING ObjectNameU; UNICODE_STRING ObjectNameU;
NTSTATUS Status; NTSTATUS Status;
RtlInitUnicodeString (&SubsystemNameU, RtlCreateUnicodeStringFromAsciiz(&SubsystemNameU,
(PWSTR)SubsystemName); (PCHAR)SubsystemName);
RtlInitUnicodeString (&ObjectTypeNameU, RtlCreateUnicodeStringFromAsciiz(&ObjectTypeNameU,
(PWSTR)ObjectTypeName); (PCHAR)ObjectTypeName);
RtlInitUnicodeString (&ObjectNameU, RtlCreateUnicodeStringFromAsciiz(&ObjectNameU,
(PWSTR)ObjectName); (PCHAR)ObjectName);
Status = NtOpenObjectAuditAlarm (&SubsystemNameU, Status = NtOpenObjectAuditAlarm(&SubsystemNameU,
HandleId, HandleId,
&ObjectTypeNameU, &ObjectTypeNameU,
&ObjectNameU, &ObjectNameU,
pSecurityDescriptor, pSecurityDescriptor,
ClientToken, ClientToken,
DesiredAccess, DesiredAccess,
GrantedAccess, GrantedAccess,
Privileges, Privileges,
ObjectCreation, ObjectCreation,
AccessGranted, AccessGranted,
(PBOOLEAN)GenerateOnClose); (PBOOLEAN)GenerateOnClose);
if (!NT_SUCCESS (Status)) RtlFreeUnicodeString(&SubsystemNameU);
RtlFreeUnicodeString(&ObjectTypeNameU);
RtlFreeUnicodeString(&ObjectNameU);
if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -375,33 +325,50 @@ ObjectOpenAuditAlarmW (LPCWSTR SubsystemName,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
ObjectPrivilegeAuditAlarmA (LPCSTR SubsystemName, ObjectOpenAuditAlarmW(LPCWSTR SubsystemName,
LPVOID HandleId, LPVOID HandleId,
HANDLE ClientToken, LPWSTR ObjectTypeName,
DWORD DesiredAccess, LPWSTR ObjectName,
PPRIVILEGE_SET Privileges, PSECURITY_DESCRIPTOR pSecurityDescriptor,
BOOL AccessGranted) HANDLE ClientToken,
DWORD DesiredAccess,
DWORD GrantedAccess,
PPRIVILEGE_SET Privileges,
BOOL ObjectCreation,
BOOL AccessGranted,
LPBOOL GenerateOnClose)
{ {
UNICODE_STRING SubsystemNameU; UNICODE_STRING SubsystemNameU;
NTSTATUS Status; UNICODE_STRING ObjectTypeNameU;
UNICODE_STRING ObjectNameU;
NTSTATUS Status;
RtlCreateUnicodeStringFromAsciiz (&SubsystemNameU, RtlInitUnicodeString(&SubsystemNameU,
(PCHAR)SubsystemName); (PWSTR)SubsystemName);
RtlInitUnicodeString(&ObjectTypeNameU,
(PWSTR)ObjectTypeName);
RtlInitUnicodeString(&ObjectNameU,
(PWSTR)ObjectName);
Status = NtPrivilegeObjectAuditAlarm (&SubsystemNameU, Status = NtOpenObjectAuditAlarm(&SubsystemNameU,
HandleId, HandleId,
ClientToken, &ObjectTypeNameU,
DesiredAccess, &ObjectNameU,
Privileges, pSecurityDescriptor,
AccessGranted); ClientToken,
RtlFreeUnicodeString (&SubsystemNameU); DesiredAccess,
if (!NT_SUCCESS (Status)) GrantedAccess,
Privileges,
ObjectCreation,
AccessGranted,
(PBOOLEAN)GenerateOnClose);
if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -409,32 +376,33 @@ ObjectPrivilegeAuditAlarmA (LPCSTR SubsystemName,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
ObjectPrivilegeAuditAlarmW (LPCWSTR SubsystemName, ObjectPrivilegeAuditAlarmA(LPCSTR SubsystemName,
LPVOID HandleId, LPVOID HandleId,
HANDLE ClientToken, HANDLE ClientToken,
DWORD DesiredAccess, DWORD DesiredAccess,
PPRIVILEGE_SET Privileges, PPRIVILEGE_SET Privileges,
BOOL AccessGranted) BOOL AccessGranted)
{ {
UNICODE_STRING SubsystemNameU; UNICODE_STRING SubsystemNameU;
NTSTATUS Status; NTSTATUS Status;
RtlInitUnicodeString (&SubsystemNameU, RtlCreateUnicodeStringFromAsciiz(&SubsystemNameU,
(PWSTR)SubsystemName); (PCHAR)SubsystemName);
Status = NtPrivilegeObjectAuditAlarm (&SubsystemNameU, Status = NtPrivilegeObjectAuditAlarm(&SubsystemNameU,
HandleId, HandleId,
ClientToken, ClientToken,
DesiredAccess, DesiredAccess,
Privileges, Privileges,
AccessGranted); AccessGranted);
if (!NT_SUCCESS (Status)) RtlFreeUnicodeString (&SubsystemNameU);
if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -442,35 +410,32 @@ ObjectPrivilegeAuditAlarmW (LPCWSTR SubsystemName,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
PrivilegedServiceAuditAlarmA (LPCSTR SubsystemName, ObjectPrivilegeAuditAlarmW(LPCWSTR SubsystemName,
LPCSTR ServiceName, LPVOID HandleId,
HANDLE ClientToken, HANDLE ClientToken,
PPRIVILEGE_SET Privileges, DWORD DesiredAccess,
BOOL AccessGranted) PPRIVILEGE_SET Privileges,
BOOL AccessGranted)
{ {
UNICODE_STRING SubsystemNameU; UNICODE_STRING SubsystemNameU;
UNICODE_STRING ServiceNameU; NTSTATUS Status;
NTSTATUS Status;
RtlCreateUnicodeStringFromAsciiz (&SubsystemNameU, RtlInitUnicodeString(&SubsystemNameU,
(PCHAR)SubsystemName); (PWSTR)SubsystemName);
RtlCreateUnicodeStringFromAsciiz (&ServiceNameU,
(PCHAR)ServiceName);
Status = NtPrivilegedServiceAuditAlarm (&SubsystemNameU, Status = NtPrivilegeObjectAuditAlarm(&SubsystemNameU,
&ServiceNameU, HandleId,
ClientToken, ClientToken,
Privileges, DesiredAccess,
AccessGranted); Privileges,
RtlFreeUnicodeString (&SubsystemNameU); AccessGranted);
RtlFreeUnicodeString (&ServiceNameU); if (!NT_SUCCESS(Status))
if (!NT_SUCCESS (Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -478,33 +443,69 @@ PrivilegedServiceAuditAlarmA (LPCSTR SubsystemName,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
PrivilegedServiceAuditAlarmW (LPCWSTR SubsystemName, PrivilegedServiceAuditAlarmA(LPCSTR SubsystemName,
LPCWSTR ServiceName, LPCSTR ServiceName,
HANDLE ClientToken, HANDLE ClientToken,
PPRIVILEGE_SET Privileges, PPRIVILEGE_SET Privileges,
BOOL AccessGranted) BOOL AccessGranted)
{ {
UNICODE_STRING SubsystemNameU; UNICODE_STRING SubsystemNameU;
UNICODE_STRING ServiceNameU; UNICODE_STRING ServiceNameU;
NTSTATUS Status; NTSTATUS Status;
RtlInitUnicodeString (&SubsystemNameU, RtlCreateUnicodeStringFromAsciiz(&SubsystemNameU,
(PWSTR)SubsystemName); (PCHAR)SubsystemName);
RtlInitUnicodeString (&ServiceNameU, RtlCreateUnicodeStringFromAsciiz(&ServiceNameU,
(PWSTR)ServiceName); (PCHAR)ServiceName);
Status = NtPrivilegedServiceAuditAlarm (&SubsystemNameU, Status = NtPrivilegedServiceAuditAlarm(&SubsystemNameU,
&ServiceNameU, &ServiceNameU,
ClientToken, ClientToken,
Privileges, Privileges,
AccessGranted); AccessGranted);
if (!NT_SUCCESS (Status)) RtlFreeUnicodeString(&SubsystemNameU);
RtlFreeUnicodeString(&ServiceNameU);
if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
}
/*
* @implemented
*/
BOOL STDCALL
PrivilegedServiceAuditAlarmW(LPCWSTR SubsystemName,
LPCWSTR ServiceName,
HANDLE ClientToken,
PPRIVILEGE_SET Privileges,
BOOL AccessGranted)
{
UNICODE_STRING SubsystemNameU;
UNICODE_STRING ServiceNameU;
NTSTATUS Status;
RtlInitUnicodeString(&SubsystemNameU,
(PWSTR)SubsystemName);
RtlInitUnicodeString(&ServiceNameU,
(PWSTR)ServiceName);
Status = NtPrivilegedServiceAuditAlarm(&SubsystemNameU,
&ServiceNameU,
ClientToken,
Privileges,
AccessGranted);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
}
return TRUE;
} }
@ -530,9 +531,9 @@ AccessCheckByTypeResultListAndAuditAlarmByHandleW(IN LPCWSTR SubsystemName,
OUT LPDWORD AccessStatusList, OUT LPDWORD AccessStatusList,
OUT LPBOOL pfGenerateOnClose) OUT LPBOOL pfGenerateOnClose)
{ {
FIXME("%s() not implemented!\n", __FUNCTION__); FIXME("%s() not implemented!\n", __FUNCTION__);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; return FALSE;
} }
@ -558,9 +559,9 @@ AccessCheckByTypeResultListAndAuditAlarmByHandleA(IN LPCSTR SubsystemName,
OUT LPDWORD AccessStatusList, OUT LPDWORD AccessStatusList,
OUT LPBOOL pfGenerateOnClose) OUT LPBOOL pfGenerateOnClose)
{ {
FIXME("%s() not implemented!\n", __FUNCTION__); FIXME("%s() not implemented!\n", __FUNCTION__);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; return FALSE;
} }
@ -585,9 +586,9 @@ AccessCheckByTypeResultListAndAuditAlarmW(IN LPCWSTR SubsystemName,
OUT LPDWORD AccessStatusList, OUT LPDWORD AccessStatusList,
OUT LPBOOL pfGenerateOnClose) OUT LPBOOL pfGenerateOnClose)
{ {
FIXME("%s() not implemented!\n", __FUNCTION__); FIXME("%s() not implemented!\n", __FUNCTION__);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; return FALSE;
} }
@ -612,9 +613,9 @@ AccessCheckByTypeResultListAndAuditAlarmA(IN LPCSTR SubsystemName,
OUT LPDWORD AccessStatusList, OUT LPDWORD AccessStatusList,
OUT LPBOOL pfGenerateOnClose) OUT LPBOOL pfGenerateOnClose)
{ {
FIXME("%s() not implemented!\n", __FUNCTION__); FIXME("%s() not implemented!\n", __FUNCTION__);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; return FALSE;
} }
@ -639,9 +640,9 @@ AccessCheckByTypeAndAuditAlarmW(IN LPCWSTR SubsystemName,
OUT LPBOOL AccessStatus, OUT LPBOOL AccessStatus,
OUT LPBOOL pfGenerateOnClose) OUT LPBOOL pfGenerateOnClose)
{ {
FIXME("%s() not implemented!\n", __FUNCTION__); FIXME("%s() not implemented!\n", __FUNCTION__);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; return FALSE;
} }
@ -666,10 +667,9 @@ AccessCheckByTypeAndAuditAlarmA(IN LPCSTR SubsystemName,
OUT LPBOOL AccessStatus, OUT LPBOOL AccessStatus,
OUT LPBOOL pfGenerateOnClose) OUT LPBOOL pfGenerateOnClose)
{ {
FIXME("%s() not implemented!\n", __FUNCTION__); FIXME("%s() not implemented!\n", __FUNCTION__);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; return FALSE;
} }
/* EOF */ /* EOF */

1028
reactos/dll/win32/advapi32/sec/misc.c
View file

File diff suppressed because it is too large Load diff

489
reactos/dll/win32/advapi32/sec/sec.c
View file

@ -21,24 +21,22 @@ WINE_DEFAULT_DEBUG_CHANNEL(advapi);
*/ */
BOOL BOOL
STDCALL STDCALL
GetSecurityDescriptorControl ( GetSecurityDescriptorControl(PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSECURITY_DESCRIPTOR pSecurityDescriptor, PSECURITY_DESCRIPTOR_CONTROL pControl,
PSECURITY_DESCRIPTOR_CONTROL pControl, LPDWORD lpdwRevision)
LPDWORD lpdwRevision
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlGetControlSecurityDescriptor (pSecurityDescriptor, Status = RtlGetControlSecurityDescriptor(pSecurityDescriptor,
pControl, pControl,
(PULONG)lpdwRevision); (PULONG)lpdwRevision);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -47,31 +45,29 @@ GetSecurityDescriptorControl (
*/ */
BOOL BOOL
STDCALL STDCALL
GetSecurityDescriptorDacl ( GetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbDaclPresent,
LPBOOL lpbDaclPresent, PACL *pDacl,
PACL *pDacl, LPBOOL lpbDaclDefaulted)
LPBOOL lpbDaclDefaulted
)
{ {
BOOLEAN DaclPresent; BOOLEAN DaclPresent;
BOOLEAN DaclDefaulted; BOOLEAN DaclDefaulted;
NTSTATUS Status; NTSTATUS Status;
Status = RtlGetDaclSecurityDescriptor (pSecurityDescriptor, Status = RtlGetDaclSecurityDescriptor(pSecurityDescriptor,
&DaclPresent, &DaclPresent,
pDacl, pDacl,
&DaclDefaulted); &DaclDefaulted);
*lpbDaclPresent = (BOOL)DaclPresent; *lpbDaclPresent = (BOOL)DaclPresent;
*lpbDaclDefaulted = (BOOL)DaclDefaulted; *lpbDaclDefaulted = (BOOL)DaclDefaulted;
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -80,27 +76,25 @@ GetSecurityDescriptorDacl (
*/ */
BOOL BOOL
STDCALL STDCALL
GetSecurityDescriptorGroup ( GetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID *pGroup,
PSID *pGroup, LPBOOL lpbGroupDefaulted)
LPBOOL lpbGroupDefaulted
)
{ {
BOOLEAN GroupDefaulted; BOOLEAN GroupDefaulted;
NTSTATUS Status; NTSTATUS Status;
Status = RtlGetGroupSecurityDescriptor (pSecurityDescriptor, Status = RtlGetGroupSecurityDescriptor(pSecurityDescriptor,
pGroup, pGroup,
&GroupDefaulted); &GroupDefaulted);
*lpbGroupDefaulted = (BOOL)GroupDefaulted; *lpbGroupDefaulted = (BOOL)GroupDefaulted;
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -109,27 +103,25 @@ GetSecurityDescriptorGroup (
*/ */
BOOL BOOL
STDCALL STDCALL
GetSecurityDescriptorOwner ( GetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID *pOwner,
PSID *pOwner, LPBOOL lpbOwnerDefaulted)
LPBOOL lpbOwnerDefaulted
)
{ {
BOOLEAN OwnerDefaulted; BOOLEAN OwnerDefaulted;
NTSTATUS Status; NTSTATUS Status;
Status = RtlGetOwnerSecurityDescriptor (pSecurityDescriptor, Status = RtlGetOwnerSecurityDescriptor(pSecurityDescriptor,
pOwner, pOwner,
&OwnerDefaulted); &OwnerDefaulted);
*lpbOwnerDefaulted = (BOOL)OwnerDefaulted; *lpbOwnerDefaulted = (BOOL)OwnerDefaulted;
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -138,15 +130,14 @@ GetSecurityDescriptorOwner (
*/ */
DWORD DWORD
STDCALL STDCALL
GetSecurityDescriptorRMControl ( GetSecurityDescriptorRMControl(PSECURITY_DESCRIPTOR SecurityDescriptor,
PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl)
PUCHAR RMControl)
{ {
if (!RtlGetSecurityDescriptorRMControl(SecurityDescriptor, if (!RtlGetSecurityDescriptorRMControl(SecurityDescriptor,
RMControl)) RMControl))
return ERROR_INVALID_DATA; return ERROR_INVALID_DATA;
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -155,31 +146,29 @@ GetSecurityDescriptorRMControl (
*/ */
BOOL BOOL
STDCALL STDCALL
GetSecurityDescriptorSacl ( GetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSECURITY_DESCRIPTOR pSecurityDescriptor, LPBOOL lpbSaclPresent,
LPBOOL lpbSaclPresent, PACL *pSacl,
PACL *pSacl, LPBOOL lpbSaclDefaulted)
LPBOOL lpbSaclDefaulted
)
{ {
BOOLEAN SaclPresent; BOOLEAN SaclPresent;
BOOLEAN SaclDefaulted; BOOLEAN SaclDefaulted;
NTSTATUS Status; NTSTATUS Status;
Status = RtlGetSaclSecurityDescriptor (pSecurityDescriptor, Status = RtlGetSaclSecurityDescriptor(pSecurityDescriptor,
&SaclPresent, &SaclPresent,
pSacl, pSacl,
&SaclDefaulted); &SaclDefaulted);
*lpbSaclPresent = (BOOL)SaclPresent; *lpbSaclPresent = (BOOL)SaclPresent;
*lpbSaclDefaulted = (BOOL)SaclDefaulted; *lpbSaclDefaulted = (BOOL)SaclDefaulted;
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -188,22 +177,20 @@ GetSecurityDescriptorSacl (
*/ */
BOOL BOOL
STDCALL STDCALL
InitializeSecurityDescriptor ( InitializeSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSECURITY_DESCRIPTOR pSecurityDescriptor, DWORD dwRevision)
DWORD dwRevision
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlCreateSecurityDescriptor (pSecurityDescriptor, Status = RtlCreateSecurityDescriptor(pSecurityDescriptor,
dwRevision); dwRevision);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -212,17 +199,15 @@ InitializeSecurityDescriptor (
*/ */
BOOL BOOL
STDCALL STDCALL
IsValidSecurityDescriptor ( IsValidSecurityDescriptor(PSECURITY_DESCRIPTOR pSecurityDescriptor)
PSECURITY_DESCRIPTOR pSecurityDescriptor
)
{ {
BOOLEAN Result; BOOLEAN Result;
Result = RtlValidSecurityDescriptor (pSecurityDescriptor); Result = RtlValidSecurityDescriptor (pSecurityDescriptor);
if (Result == FALSE) if (Result == FALSE)
SetLastError (RtlNtStatusToDosError (STATUS_INVALID_SECURITY_DESCR)); SetLastError(RtlNtStatusToDosError(STATUS_INVALID_SECURITY_DESCR));
return (BOOL)Result; return (BOOL)Result;
} }
@ -231,19 +216,17 @@ IsValidSecurityDescriptor (
*/ */
BOOL BOOL
STDCALL STDCALL
MakeAbsoluteSD ( MakeAbsoluteSD(PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, LPDWORD lpdwAbsoluteSecurityDescriptorSize,
LPDWORD lpdwAbsoluteSecurityDescriptorSize, PACL pDacl,
PACL pDacl, LPDWORD lpdwDaclSize,
LPDWORD lpdwDaclSize, PACL pSacl,
PACL pSacl, LPDWORD lpdwSaclSize,
LPDWORD lpdwSaclSize, PSID pOwner,
PSID pOwner, LPDWORD lpdwOwnerSize,
LPDWORD lpdwOwnerSize, PSID pPrimaryGroup,
PSID pPrimaryGroup, LPDWORD lpdwPrimaryGroupSize)
LPDWORD lpdwPrimaryGroupSize
)
{ {
NTSTATUS Status; NTSTATUS Status;
@ -280,13 +263,13 @@ MakeAbsoluteSD2(IN OUT PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
Status = RtlSelfRelativeToAbsoluteSD2(pSelfRelativeSecurityDescriptor, Status = RtlSelfRelativeToAbsoluteSD2(pSelfRelativeSecurityDescriptor,
lpdwBufferSize); lpdwBufferSize);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -295,24 +278,22 @@ MakeAbsoluteSD2(IN OUT PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
*/ */
BOOL BOOL
STDCALL STDCALL
MakeSelfRelativeSD ( MakeSelfRelativeSD(PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor, PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor, LPDWORD lpdwBufferLength)
LPDWORD lpdwBufferLength
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlAbsoluteToSelfRelativeSD (pAbsoluteSecurityDescriptor, Status = RtlAbsoluteToSelfRelativeSD(pAbsoluteSecurityDescriptor,
pSelfRelativeSecurityDescriptor, pSelfRelativeSecurityDescriptor,
(PULONG)lpdwBufferLength); (PULONG)lpdwBufferLength);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -321,23 +302,22 @@ MakeSelfRelativeSD (
*/ */
BOOL BOOL
STDCALL STDCALL
SetSecurityDescriptorControl ( SetSecurityDescriptorControl(PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSECURITY_DESCRIPTOR pSecurityDescriptor, SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest,
SECURITY_DESCRIPTOR_CONTROL ControlBitsOfInterest, SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet)
SECURITY_DESCRIPTOR_CONTROL ControlBitsToSet)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlSetControlSecurityDescriptor(pSecurityDescriptor, Status = RtlSetControlSecurityDescriptor(pSecurityDescriptor,
ControlBitsOfInterest, ControlBitsOfInterest,
ControlBitsToSet); ControlBitsToSet);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -346,26 +326,24 @@ SetSecurityDescriptorControl (
*/ */
BOOL BOOL
STDCALL STDCALL
SetSecurityDescriptorDacl ( SetSecurityDescriptorDacl(PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bDaclPresent,
BOOL bDaclPresent, PACL pDacl,
PACL pDacl, BOOL bDaclDefaulted)
BOOL bDaclDefaulted
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlSetDaclSecurityDescriptor (pSecurityDescriptor, Status = RtlSetDaclSecurityDescriptor(pSecurityDescriptor,
bDaclPresent, bDaclPresent,
pDacl, pDacl,
bDaclDefaulted); bDaclDefaulted);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -374,24 +352,22 @@ SetSecurityDescriptorDacl (
*/ */
BOOL BOOL
STDCALL STDCALL
SetSecurityDescriptorGroup ( SetSecurityDescriptorGroup(PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pGroup,
PSID pGroup, BOOL bGroupDefaulted)
BOOL bGroupDefaulted
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlSetGroupSecurityDescriptor (pSecurityDescriptor, Status = RtlSetGroupSecurityDescriptor(pSecurityDescriptor,
pGroup, pGroup,
bGroupDefaulted); bGroupDefaulted);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -400,24 +376,22 @@ SetSecurityDescriptorGroup (
*/ */
BOOL BOOL
STDCALL STDCALL
SetSecurityDescriptorOwner ( SetSecurityDescriptorOwner(PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSECURITY_DESCRIPTOR pSecurityDescriptor, PSID pOwner,
PSID pOwner, BOOL bOwnerDefaulted)
BOOL bOwnerDefaulted
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlSetOwnerSecurityDescriptor (pSecurityDescriptor, Status = RtlSetOwnerSecurityDescriptor(pSecurityDescriptor,
pOwner, pOwner,
bOwnerDefaulted); bOwnerDefaulted);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -426,14 +400,13 @@ SetSecurityDescriptorOwner (
*/ */
DWORD DWORD
STDCALL STDCALL
SetSecurityDescriptorRMControl ( SetSecurityDescriptorRMControl(PSECURITY_DESCRIPTOR SecurityDescriptor,
PSECURITY_DESCRIPTOR SecurityDescriptor, PUCHAR RMControl)
PUCHAR RMControl)
{ {
RtlSetSecurityDescriptorRMControl(SecurityDescriptor, RtlSetSecurityDescriptorRMControl(SecurityDescriptor,
RMControl); RMControl);
return ERROR_SUCCESS; return ERROR_SUCCESS;
} }
@ -442,26 +415,24 @@ SetSecurityDescriptorRMControl (
*/ */
BOOL BOOL
STDCALL STDCALL
SetSecurityDescriptorSacl ( SetSecurityDescriptorSacl(PSECURITY_DESCRIPTOR pSecurityDescriptor,
PSECURITY_DESCRIPTOR pSecurityDescriptor, BOOL bSaclPresent,
BOOL bSaclPresent, PACL pSacl,
PACL pSacl, BOOL bSaclDefaulted)
BOOL bSaclDefaulted
)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlSetSaclSecurityDescriptor (pSecurityDescriptor, Status = RtlSetSaclSecurityDescriptor(pSecurityDescriptor,
bSaclPresent, bSaclPresent,
pSacl, pSacl,
bSaclDefaulted); bSaclDefaulted);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -574,10 +545,12 @@ BOOL WINAPI DecryptFileW(LPCWSTR lpFileName, DWORD dwReserved)
return TRUE; return TRUE;
} }
/* /*
* @implemented * @implemented
*/ */
BOOL WINAPI DecryptFileA(LPCSTR lpFileName, DWORD dwReserved) BOOL WINAPI
DecryptFileA(LPCSTR lpFileName, DWORD dwReserved)
{ {
UNICODE_STRING FileName; UNICODE_STRING FileName;
NTSTATUS Status; NTSTATUS Status;
@ -597,20 +570,24 @@ BOOL WINAPI DecryptFileA(LPCSTR lpFileName, DWORD dwReserved)
return ret; return ret;
} }
/* /*
* @unimplemented * @unimplemented
*/ */
BOOL WINAPI EncryptFileW(LPCWSTR lpFileName) BOOL WINAPI
EncryptFileW(LPCWSTR lpFileName)
{ {
FIXME("%s() not implemented!\n", __FUNCTION__); FIXME("%s() not implemented!\n", __FUNCTION__);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return TRUE; return TRUE;
} }
/* /*
* @implemented * @implemented
*/ */
BOOL WINAPI EncryptFileA(LPCSTR lpFileName) BOOL WINAPI
EncryptFileA(LPCSTR lpFileName)
{ {
UNICODE_STRING FileName; UNICODE_STRING FileName;
NTSTATUS Status; NTSTATUS Status;
@ -630,24 +607,32 @@ BOOL WINAPI EncryptFileA(LPCSTR lpFileName)
return ret; return ret;
} }
BOOL WINAPI ConvertSecurityDescriptorToStringSecurityDescriptorW(
PSECURITY_DESCRIPTOR pSecurityDescriptor, /*
DWORD dword, * @unimplemented
SECURITY_INFORMATION SecurityInformation, */
LPWSTR* lpwstr, BOOL WINAPI
PULONG pulong) ConvertSecurityDescriptorToStringSecurityDescriptorW(PSECURITY_DESCRIPTOR pSecurityDescriptor,
DWORD dword,
SECURITY_INFORMATION SecurityInformation,
LPWSTR *lpwstr,
PULONG pulong)
{ {
FIXME("%s() not implemented!\n", __FUNCTION__); FIXME("%s() not implemented!\n", __FUNCTION__);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; return FALSE;
} }
BOOL WINAPI ConvertSecurityDescriptorToStringSecurityDescriptorA(
PSECURITY_DESCRIPTOR pSecurityDescriptor, /*
DWORD dword, * @unimplemented
SECURITY_INFORMATION SecurityInformation, */
LPSTR* lpstr, BOOL WINAPI
PULONG pulong) ConvertSecurityDescriptorToStringSecurityDescriptorA(PSECURITY_DESCRIPTOR pSecurityDescriptor,
DWORD dword,
SECURITY_INFORMATION SecurityInformation,
LPSTR *lpstr,
PULONG pulong)
{ {
FIXME("%s() not implemented!\n", __FUNCTION__); FIXME("%s() not implemented!\n", __FUNCTION__);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);

302
reactos/dll/win32/advapi32/sec/sid.c
View file

@ -536,16 +536,16 @@ ParseAceString(
BOOL STDCALL BOOL STDCALL
AllocateLocallyUniqueId(PLUID Luid) AllocateLocallyUniqueId(PLUID Luid)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = NtAllocateLocallyUniqueId (Luid); Status = NtAllocateLocallyUniqueId (Luid);
if (!NT_SUCCESS (Status)) if (!NT_SUCCESS (Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -553,38 +553,38 @@ AllocateLocallyUniqueId(PLUID Luid)
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
AllocateAndInitializeSid (PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
BYTE nSubAuthorityCount, BYTE nSubAuthorityCount,
DWORD dwSubAuthority0, DWORD dwSubAuthority0,
DWORD dwSubAuthority1, DWORD dwSubAuthority1,
DWORD dwSubAuthority2, DWORD dwSubAuthority2,
DWORD dwSubAuthority3, DWORD dwSubAuthority3,
DWORD dwSubAuthority4, DWORD dwSubAuthority4,
DWORD dwSubAuthority5, DWORD dwSubAuthority5,
DWORD dwSubAuthority6, DWORD dwSubAuthority6,
DWORD dwSubAuthority7, DWORD dwSubAuthority7,
PSID *pSid) PSID *pSid)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlAllocateAndInitializeSid (pIdentifierAuthority, Status = RtlAllocateAndInitializeSid(pIdentifierAuthority,
nSubAuthorityCount, nSubAuthorityCount,
dwSubAuthority0, dwSubAuthority0,
dwSubAuthority1, dwSubAuthority1,
dwSubAuthority2, dwSubAuthority2,
dwSubAuthority3, dwSubAuthority3,
dwSubAuthority4, dwSubAuthority4,
dwSubAuthority5, dwSubAuthority5,
dwSubAuthority6, dwSubAuthority6,
dwSubAuthority7, dwSubAuthority7,
pSid); pSid);
if (!NT_SUCCESS (Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -592,23 +592,25 @@ AllocateAndInitializeSid (PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
CopySid (DWORD nDestinationSidLength, CopySid(DWORD nDestinationSidLength,
PSID pDestinationSid, PSID pDestinationSid,
PSID pSourceSid) PSID pSourceSid)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlCopySid (nDestinationSidLength, Status = RtlCopySid(nDestinationSidLength,
pDestinationSid, pDestinationSid,
pSourceSid); pSourceSid);
if (!NT_SUCCESS (Status)) if (!NT_SUCCESS (Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
/****************************************************************************** /******************************************************************************
* ConvertStringSecurityDescriptorToSecurityDescriptorW [ADVAPI32.@] * ConvertStringSecurityDescriptorToSecurityDescriptorW [ADVAPI32.@]
* @implemented * @implemented
@ -830,10 +832,10 @@ BOOL WINAPI ConvertStringSecurityDescriptorToSecurityDescriptorA(
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
EqualPrefixSid (PSID pSid1, EqualPrefixSid(PSID pSid1,
PSID pSid2) PSID pSid2)
{ {
return RtlEqualPrefixSid (pSid1, pSid2); return RtlEqualPrefixSid (pSid1, pSid2);
} }
@ -841,10 +843,10 @@ EqualPrefixSid (PSID pSid1,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
EqualSid (PSID pSid1, EqualSid(PSID pSid1,
PSID pSid2) PSID pSid2)
{ {
return RtlEqualSid (pSid1, pSid2); return RtlEqualSid (pSid1, pSid2);
} }
@ -856,9 +858,9 @@ EqualSid (PSID pSid1,
* even thou it's defined to return a PVOID... * even thou it's defined to return a PVOID...
*/ */
PVOID STDCALL PVOID STDCALL
FreeSid (PSID pSid) FreeSid(PSID pSid)
{ {
return RtlFreeSid (pSid); return RtlFreeSid(pSid);
} }
@ -866,9 +868,9 @@ FreeSid (PSID pSid)
* @implemented * @implemented
*/ */
DWORD STDCALL DWORD STDCALL
GetLengthSid (PSID pSid) GetLengthSid(PSID pSid)
{ {
return (DWORD)RtlLengthSid (pSid); return (DWORD)RtlLengthSid(pSid);
} }
@ -876,9 +878,9 @@ GetLengthSid (PSID pSid)
* @implemented * @implemented
*/ */
PSID_IDENTIFIER_AUTHORITY STDCALL PSID_IDENTIFIER_AUTHORITY STDCALL
GetSidIdentifierAuthority (PSID pSid) GetSidIdentifierAuthority(PSID pSid)
{ {
return RtlIdentifierAuthoritySid (pSid); return RtlIdentifierAuthoritySid(pSid);
} }
@ -886,9 +888,9 @@ GetSidIdentifierAuthority (PSID pSid)
* @implemented * @implemented
*/ */
DWORD STDCALL DWORD STDCALL
GetSidLengthRequired (UCHAR nSubAuthorityCount) GetSidLengthRequired(UCHAR nSubAuthorityCount)
{ {
return (DWORD)RtlLengthRequiredSid (nSubAuthorityCount); return (DWORD)RtlLengthRequiredSid(nSubAuthorityCount);
} }
@ -896,10 +898,10 @@ GetSidLengthRequired (UCHAR nSubAuthorityCount)
* @implemented * @implemented
*/ */
PDWORD STDCALL PDWORD STDCALL
GetSidSubAuthority (PSID pSid, GetSidSubAuthority(PSID pSid,
DWORD nSubAuthority) DWORD nSubAuthority)
{ {
return (PDWORD)RtlSubAuthoritySid (pSid, nSubAuthority); return (PDWORD)RtlSubAuthoritySid(pSid, nSubAuthority);
} }
@ -907,9 +909,9 @@ GetSidSubAuthority (PSID pSid,
* @implemented * @implemented
*/ */
PUCHAR STDCALL PUCHAR STDCALL
GetSidSubAuthorityCount (PSID pSid) GetSidSubAuthorityCount(PSID pSid)
{ {
return RtlSubAuthorityCountSid (pSid); return RtlSubAuthorityCountSid(pSid);
} }
@ -917,22 +919,22 @@ GetSidSubAuthorityCount (PSID pSid)
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
InitializeSid (PSID Sid, InitializeSid(PSID Sid,
PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
BYTE nSubAuthorityCount) BYTE nSubAuthorityCount)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = RtlInitializeSid (Sid, Status = RtlInitializeSid(Sid,
pIdentifierAuthority, pIdentifierAuthority,
nSubAuthorityCount); nSubAuthorityCount);
if (!NT_SUCCESS (Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -940,60 +942,63 @@ InitializeSid (PSID Sid,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
IsValidSid (PSID pSid) IsValidSid(PSID pSid)
{ {
return (BOOL)RtlValidSid (pSid); return (BOOL)RtlValidSid(pSid);
} }
/* /*
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
ConvertSidToStringSidW(PSID Sid, LPWSTR *StringSid) ConvertSidToStringSidW(PSID Sid,
LPWSTR *StringSid)
{ {
NTSTATUS Status; NTSTATUS Status;
UNICODE_STRING UnicodeString; UNICODE_STRING UnicodeString;
WCHAR FixedBuffer[64]; WCHAR FixedBuffer[64];
if (! RtlValidSid(Sid)) if (!RtlValidSid(Sid))
{ {
SetLastError(ERROR_INVALID_SID); SetLastError(ERROR_INVALID_SID);
return FALSE; return FALSE;
} }
UnicodeString.Length = 0; UnicodeString.Length = 0;
UnicodeString.MaximumLength = sizeof(FixedBuffer); UnicodeString.MaximumLength = sizeof(FixedBuffer);
UnicodeString.Buffer = FixedBuffer; UnicodeString.Buffer = FixedBuffer;
Status = RtlConvertSidToUnicodeString(&UnicodeString, Sid, FALSE); Status = RtlConvertSidToUnicodeString(&UnicodeString, Sid, FALSE);
if (STATUS_BUFFER_TOO_SMALL == Status) if (STATUS_BUFFER_TOO_SMALL == Status)
{ {
Status = RtlConvertSidToUnicodeString(&UnicodeString, Sid, TRUE); Status = RtlConvertSidToUnicodeString(&UnicodeString, Sid, TRUE);
}
if (! NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
} }
*StringSid = LocalAlloc(LMEM_FIXED, UnicodeString.Length + sizeof(WCHAR)); if (!NT_SUCCESS(Status))
if (NULL == *StringSid)
{ {
if (UnicodeString.Buffer != FixedBuffer) SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
}
*StringSid = LocalAlloc(LMEM_FIXED, UnicodeString.Length + sizeof(WCHAR));
if (NULL == *StringSid)
{
if (UnicodeString.Buffer != FixedBuffer)
{ {
RtlFreeUnicodeString(&UnicodeString); RtlFreeUnicodeString(&UnicodeString);
} }
SetLastError(ERROR_NOT_ENOUGH_MEMORY); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE; return FALSE;
} }
MoveMemory(*StringSid, UnicodeString.Buffer, UnicodeString.Length); MoveMemory(*StringSid, UnicodeString.Buffer, UnicodeString.Length);
ZeroMemory((PCHAR) *StringSid + UnicodeString.Length, sizeof(WCHAR)); ZeroMemory((PCHAR) *StringSid + UnicodeString.Length, sizeof(WCHAR));
if (UnicodeString.Buffer != FixedBuffer) if (UnicodeString.Buffer != FixedBuffer)
{ {
RtlFreeUnicodeString(&UnicodeString); RtlFreeUnicodeString(&UnicodeString);
} }
return TRUE; return TRUE;
} }
@ -1001,41 +1006,43 @@ ConvertSidToStringSidW(PSID Sid, LPWSTR *StringSid)
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
ConvertSidToStringSidA(PSID Sid, LPSTR *StringSid) ConvertSidToStringSidA(PSID Sid,
LPSTR *StringSid)
{ {
LPWSTR StringSidW; LPWSTR StringSidW;
int Len; int Len;
if (! ConvertSidToStringSidW(Sid, &StringSidW)) if (!ConvertSidToStringSidW(Sid, &StringSidW))
{ {
return FALSE; return FALSE;
} }
Len = WideCharToMultiByte(CP_ACP, 0, StringSidW, -1, NULL, 0, NULL, NULL); Len = WideCharToMultiByte(CP_ACP, 0, StringSidW, -1, NULL, 0, NULL, NULL);
if (Len <= 0) if (Len <= 0)
{ {
LocalFree(StringSidW); LocalFree(StringSidW);
SetLastError(ERROR_NOT_ENOUGH_MEMORY); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE; return FALSE;
}
*StringSid = LocalAlloc(LMEM_FIXED, Len);
if (NULL == *StringSid)
{
LocalFree(StringSidW);
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
} }
if (! WideCharToMultiByte(CP_ACP, 0, StringSidW, -1, *StringSid, Len, NULL, NULL)) *StringSid = LocalAlloc(LMEM_FIXED, Len);
if (NULL == *StringSid)
{ {
LocalFree(StringSid); LocalFree(StringSidW);
LocalFree(StringSidW); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE; return FALSE;
} }
LocalFree(StringSidW); if (!WideCharToMultiByte(CP_ACP, 0, StringSidW, -1, *StringSid, Len, NULL, NULL))
{
LocalFree(StringSid);
LocalFree(StringSidW);
return FALSE;
}
return TRUE; LocalFree(StringSidW);
return TRUE;
} }
@ -1077,22 +1084,27 @@ CreateWellKnownSid(IN WELL_KNOWN_SID_TYPE WellKnownSidType,
int i; int i;
TRACE("(%d, %s, %p, %p)\n", WellKnownSidType, debugstr_sid(DomainSid), pSid, cbSid); TRACE("(%d, %s, %p, %p)\n", WellKnownSidType, debugstr_sid(DomainSid), pSid, cbSid);
if (DomainSid != NULL) { if (DomainSid != NULL)
{
FIXME("Only local computer supported!\n"); FIXME("Only local computer supported!\n");
SetLastError(ERROR_INVALID_PARAMETER); /* FIXME */ SetLastError(ERROR_INVALID_PARAMETER); /* FIXME */
return FALSE; return FALSE;
} }
if (cbSid == NULL || pSid == NULL) { if (cbSid == NULL || pSid == NULL)
{
SetLastError(ERROR_INVALID_PARAMETER); SetLastError(ERROR_INVALID_PARAMETER);
return FALSE; return FALSE;
} }
for (i = 0; i < sizeof(WellKnownSids)/sizeof(WellKnownSids[0]); i++) { for (i = 0; i < sizeof(WellKnownSids)/sizeof(WellKnownSids[0]); i++)
if (WellKnownSids[i].Type == WellKnownSidType) { {
if (WellKnownSids[i].Type == WellKnownSidType)
{
DWORD length = GetSidLengthRequired(WellKnownSids[i].Sid.SubAuthorityCount); DWORD length = GetSidLengthRequired(WellKnownSids[i].Sid.SubAuthorityCount);
if (*cbSid < length) { if (*cbSid < length)
{
SetLastError(ERROR_INSUFFICIENT_BUFFER); SetLastError(ERROR_INSUFFICIENT_BUFFER);
return FALSE; return FALSE;
} }
@ -1118,10 +1130,14 @@ IsWellKnownSid(IN PSID pSid,
int i; int i;
TRACE("(%s, %d)\n", debugstr_sid(pSid), WellKnownSidType); TRACE("(%s, %d)\n", debugstr_sid(pSid), WellKnownSidType);
for (i = 0; i < sizeof(WellKnownSids)/sizeof(WellKnownSids[0]); i++) for (i = 0; i < sizeof(WellKnownSids) / sizeof(WellKnownSids[0]); i++)
{
if (WellKnownSids[i].Type == WellKnownSidType) if (WellKnownSids[i].Type == WellKnownSidType)
{
if (EqualSid(pSid, (PSID)((ULONG_PTR)&WellKnownSids[i].Sid.Revision))) if (EqualSid(pSid, (PSID)((ULONG_PTR)&WellKnownSids[i].Sid.Revision)))
return TRUE; return TRUE;
}
}
return FALSE; return FALSE;
} }
@ -1131,9 +1147,8 @@ IsWellKnownSid(IN PSID pSid,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
ConvertStringSidToSidA( ConvertStringSidToSidA(IN LPCSTR StringSid,
IN LPCSTR StringSid, OUT PSID* sid)
OUT PSID* sid)
{ {
BOOL bRetVal = FALSE; BOOL bRetVal = FALSE;
@ -1150,10 +1165,12 @@ ConvertStringSidToSidA(
return bRetVal; return bRetVal;
} }
/****************************************************************************** /******************************************************************************
* ComputeStringSidSize * ComputeStringSidSize
*/ */
static DWORD ComputeStringSidSize(LPCWSTR StringSid) static DWORD
ComputeStringSidSize(LPCWSTR StringSid)
{ {
DWORD size = sizeof(SID); DWORD size = sizeof(SID);
@ -1229,16 +1246,15 @@ static const RECORD SidTable[] =
* @implemented * @implemented
*/ */
BOOL WINAPI BOOL WINAPI
ConvertStringSidToSidW( ConvertStringSidToSidW(IN LPCWSTR StringSid,
IN LPCWSTR StringSid, OUT PSID* sid)
OUT PSID* sid)
{ {
DWORD size; DWORD size;
DWORD i, cBytes, identAuth, csubauth; DWORD i, cBytes, identAuth, csubauth;
BOOL ret; BOOL ret;
SID* pisid; SID* pisid;
TRACE("%s %p\n", debugstr_w(StringSid), sid); TRACE("%s %p\n", debugstr_w(StringSid), sid);
if (!StringSid) if (!StringSid)
{ {

68
reactos/dll/win32/advapi32/sec/trustee.c
View file

@ -20,8 +20,8 @@ VOID WINAPI
BuildImpersonateTrusteeA(PTRUSTEE_A pTrustee, BuildImpersonateTrusteeA(PTRUSTEE_A pTrustee,
PTRUSTEE_A pImpersonateTrustee) PTRUSTEE_A pImpersonateTrustee)
{ {
pTrustee->pMultipleTrustee = pImpersonateTrustee; pTrustee->pMultipleTrustee = pImpersonateTrustee;
pTrustee->MultipleTrusteeOperation = TRUSTEE_IS_IMPERSONATE; pTrustee->MultipleTrusteeOperation = TRUSTEE_IS_IMPERSONATE;
} }
@ -32,8 +32,8 @@ VOID WINAPI
BuildImpersonateTrusteeW(PTRUSTEE_W pTrustee, BuildImpersonateTrusteeW(PTRUSTEE_W pTrustee,
PTRUSTEE_W pImpersonateTrustee) PTRUSTEE_W pImpersonateTrustee)
{ {
pTrustee->pMultipleTrustee = pImpersonateTrustee; pTrustee->pMultipleTrustee = pImpersonateTrustee;
pTrustee->MultipleTrusteeOperation = TRUSTEE_IS_IMPERSONATE; pTrustee->MultipleTrusteeOperation = TRUSTEE_IS_IMPERSONATE;
} }
@ -131,7 +131,8 @@ BuildImpersonateExplicitAccessWithNameW(PEXPLICIT_ACCESS_W pExplicitAccess,
* BuildTrusteeWithSidA [ADVAPI32.@] * BuildTrusteeWithSidA [ADVAPI32.@]
*/ */
VOID WINAPI VOID WINAPI
BuildTrusteeWithSidA(PTRUSTEE_A pTrustee, PSID pSid) BuildTrusteeWithSidA(PTRUSTEE_A pTrustee,
PSID pSid)
{ {
TRACE("%p %p\n", pTrustee, pSid); TRACE("%p %p\n", pTrustee, pSid);
@ -147,7 +148,8 @@ BuildTrusteeWithSidA(PTRUSTEE_A pTrustee, PSID pSid)
* BuildTrusteeWithSidW [ADVAPI32.@] * BuildTrusteeWithSidW [ADVAPI32.@]
*/ */
VOID WINAPI VOID WINAPI
BuildTrusteeWithSidW(PTRUSTEE_W pTrustee, PSID pSid) BuildTrusteeWithSidW(PTRUSTEE_W pTrustee,
PSID pSid)
{ {
TRACE("%p %p\n", pTrustee, pSid); TRACE("%p %p\n", pTrustee, pSid);
@ -163,7 +165,8 @@ BuildTrusteeWithSidW(PTRUSTEE_W pTrustee, PSID pSid)
* BuildTrusteeWithNameA [ADVAPI32.@] * BuildTrusteeWithNameA [ADVAPI32.@]
*/ */
VOID WINAPI VOID WINAPI
BuildTrusteeWithNameA(PTRUSTEE_A pTrustee, LPSTR name) BuildTrusteeWithNameA(PTRUSTEE_A pTrustee,
LPSTR name)
{ {
TRACE("%p %s\n", pTrustee, name); TRACE("%p %s\n", pTrustee, name);
@ -179,7 +182,8 @@ BuildTrusteeWithNameA(PTRUSTEE_A pTrustee, LPSTR name)
* BuildTrusteeWithNameW [ADVAPI32.@] * BuildTrusteeWithNameW [ADVAPI32.@]
*/ */
VOID WINAPI VOID WINAPI
BuildTrusteeWithNameW(PTRUSTEE_W pTrustee, LPWSTR name) BuildTrusteeWithNameW(PTRUSTEE_W pTrustee,
LPWSTR name)
{ {
TRACE("%p %s\n", pTrustee, name); TRACE("%p %s\n", pTrustee, name);
@ -195,9 +199,12 @@ BuildTrusteeWithNameW(PTRUSTEE_W pTrustee, LPWSTR name)
* BuildTrusteeWithObjectsAndNameA [ADVAPI32.@] * BuildTrusteeWithObjectsAndNameA [ADVAPI32.@]
*/ */
VOID WINAPI VOID WINAPI
BuildTrusteeWithObjectsAndNameA(PTRUSTEEA pTrustee, POBJECTS_AND_NAME_A pObjName, BuildTrusteeWithObjectsAndNameA(PTRUSTEEA pTrustee,
SE_OBJECT_TYPE ObjectType, LPSTR ObjectTypeName, POBJECTS_AND_NAME_A pObjName,
LPSTR InheritedObjectTypeName, LPSTR Name) SE_OBJECT_TYPE ObjectType,
LPSTR ObjectTypeName,
LPSTR InheritedObjectTypeName,
LPSTR Name)
{ {
DWORD ObjectsPresent = 0; DWORD ObjectsPresent = 0;
@ -233,9 +240,12 @@ BuildTrusteeWithObjectsAndNameA(PTRUSTEEA pTrustee, POBJECTS_AND_NAME_A pObjName
* BuildTrusteeWithObjectsAndNameW [ADVAPI32.@] * BuildTrusteeWithObjectsAndNameW [ADVAPI32.@]
*/ */
VOID WINAPI VOID WINAPI
BuildTrusteeWithObjectsAndNameW(PTRUSTEEW pTrustee, POBJECTS_AND_NAME_W pObjName, BuildTrusteeWithObjectsAndNameW(PTRUSTEEW pTrustee,
SE_OBJECT_TYPE ObjectType, LPWSTR ObjectTypeName, POBJECTS_AND_NAME_W pObjName,
LPWSTR InheritedObjectTypeName, LPWSTR Name) SE_OBJECT_TYPE ObjectType,
LPWSTR ObjectTypeName,
LPWSTR InheritedObjectTypeName,
LPWSTR Name)
{ {
DWORD ObjectsPresent = 0; DWORD ObjectsPresent = 0;
@ -271,8 +281,11 @@ BuildTrusteeWithObjectsAndNameW(PTRUSTEEW pTrustee, POBJECTS_AND_NAME_W pObjName
* BuildTrusteeWithObjectsAndSidA [ADVAPI32.@] * BuildTrusteeWithObjectsAndSidA [ADVAPI32.@]
*/ */
VOID WINAPI VOID WINAPI
BuildTrusteeWithObjectsAndSidA(PTRUSTEEA pTrustee, POBJECTS_AND_SID pObjSid, BuildTrusteeWithObjectsAndSidA(PTRUSTEEA pTrustee,
GUID* pObjectGuid, GUID* pInheritedObjectGuid, PSID pSid) POBJECTS_AND_SID pObjSid,
GUID *pObjectGuid,
GUID *pInheritedObjectGuid,
PSID pSid)
{ {
DWORD ObjectsPresent = 0; DWORD ObjectsPresent = 0;
@ -317,8 +330,11 @@ BuildTrusteeWithObjectsAndSidA(PTRUSTEEA pTrustee, POBJECTS_AND_SID pObjSid,
* BuildTrusteeWithObjectsAndSidW [ADVAPI32.@] * BuildTrusteeWithObjectsAndSidW [ADVAPI32.@]
*/ */
VOID WINAPI VOID WINAPI
BuildTrusteeWithObjectsAndSidW(PTRUSTEEW pTrustee, POBJECTS_AND_SID pObjSid, BuildTrusteeWithObjectsAndSidW(PTRUSTEEW pTrustee,
GUID* pObjectGuid, GUID* pInheritedObjectGuid, PSID pSid) POBJECTS_AND_SID pObjSid,
GUID *pObjectGuid,
GUID *pInheritedObjectGuid,
PSID pSid)
{ {
DWORD ObjectsPresent = 0; DWORD ObjectsPresent = 0;
@ -365,7 +381,7 @@ BuildTrusteeWithObjectsAndSidW(PTRUSTEEW pTrustee, POBJECTS_AND_SID pObjSid,
PTRUSTEEA WINAPI PTRUSTEEA WINAPI
GetMultipleTrusteeA(PTRUSTEE_A pTrustee) GetMultipleTrusteeA(PTRUSTEE_A pTrustee)
{ {
return pTrustee->pMultipleTrustee; return pTrustee->pMultipleTrustee;
} }
@ -375,7 +391,7 @@ GetMultipleTrusteeA(PTRUSTEE_A pTrustee)
PTRUSTEEW WINAPI PTRUSTEEW WINAPI
GetMultipleTrusteeW(PTRUSTEE_W pTrustee) GetMultipleTrusteeW(PTRUSTEE_W pTrustee)
{ {
return pTrustee->pMultipleTrustee; return pTrustee->pMultipleTrustee;
} }
@ -385,7 +401,7 @@ GetMultipleTrusteeW(PTRUSTEE_W pTrustee)
MULTIPLE_TRUSTEE_OPERATION WINAPI MULTIPLE_TRUSTEE_OPERATION WINAPI
GetMultipleTrusteeOperationA(PTRUSTEE_A pTrustee) GetMultipleTrusteeOperationA(PTRUSTEE_A pTrustee)
{ {
return pTrustee->MultipleTrusteeOperation; return pTrustee->MultipleTrusteeOperation;
} }
@ -395,7 +411,7 @@ GetMultipleTrusteeOperationA(PTRUSTEE_A pTrustee)
MULTIPLE_TRUSTEE_OPERATION WINAPI MULTIPLE_TRUSTEE_OPERATION WINAPI
GetMultipleTrusteeOperationW(PTRUSTEE_W pTrustee) GetMultipleTrusteeOperationW(PTRUSTEE_W pTrustee)
{ {
return pTrustee->MultipleTrusteeOperation; return pTrustee->MultipleTrusteeOperation;
} }
@ -405,7 +421,7 @@ GetMultipleTrusteeOperationW(PTRUSTEE_W pTrustee)
TRUSTEE_FORM WINAPI TRUSTEE_FORM WINAPI
GetTrusteeFormA(PTRUSTEE_A pTrustee) GetTrusteeFormA(PTRUSTEE_A pTrustee)
{ {
return pTrustee->TrusteeForm; return pTrustee->TrusteeForm;
} }
@ -415,7 +431,7 @@ GetTrusteeFormA(PTRUSTEE_A pTrustee)
TRUSTEE_FORM WINAPI TRUSTEE_FORM WINAPI
GetTrusteeFormW(PTRUSTEE_W pTrustee) GetTrusteeFormW(PTRUSTEE_W pTrustee)
{ {
return pTrustee->TrusteeForm; return pTrustee->TrusteeForm;
} }
@ -445,7 +461,7 @@ GetTrusteeNameW(PTRUSTEE_W pTrustee)
TRUSTEE_TYPE WINAPI TRUSTEE_TYPE WINAPI
GetTrusteeTypeA(PTRUSTEE_A pTrustee) GetTrusteeTypeA(PTRUSTEE_A pTrustee)
{ {
return pTrustee->TrusteeType; return pTrustee->TrusteeType;
} }
@ -455,7 +471,7 @@ GetTrusteeTypeA(PTRUSTEE_A pTrustee)
TRUSTEE_TYPE WINAPI TRUSTEE_TYPE WINAPI
GetTrusteeTypeW(PTRUSTEE_W pTrustee) GetTrusteeTypeW(PTRUSTEE_W pTrustee)
{ {
return pTrustee->TrusteeType; return pTrustee->TrusteeType;
} }
/* EOF */ /* EOF */

384
reactos/dll/win32/advapi32/service/eventlog.c
View file

@ -40,9 +40,8 @@ static RPC_UNICODE_STRING EmptyString = { 0, 0, L"" };
* BackupEventLogA [ADVAPI32.@] * BackupEventLogA [ADVAPI32.@]
*/ */
BOOL WINAPI BOOL WINAPI
BackupEventLogA( BackupEventLogA(IN HANDLE hEventLog,
IN HANDLE hEventLog, IN LPCSTR lpBackupFileName)
IN LPCSTR lpBackupFileName)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -60,16 +59,16 @@ BackupEventLogA(
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
} }
Status = ElfrBackupELFA(
pLog->BindingHandle,
pLog->LogHandle,
&BackupFileName);
Status = ElfrBackupELFA(pLog->BindingHandle,
pLog->LogHandle,
&BackupFileName);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -81,9 +80,8 @@ BackupEventLogA(
* lpBackupFileName [] * lpBackupFileName []
*/ */
BOOL WINAPI BOOL WINAPI
BackupEventLogW( BackupEventLogW(IN HANDLE hEventLog,
IN HANDLE hEventLog, IN LPCWSTR lpBackupFileName)
IN LPCWSTR lpBackupFileName)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -101,16 +99,16 @@ BackupEventLogW(
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
} }
Status = ElfrBackupELFW(
pLog->BindingHandle,
pLog->LogHandle,
&BackupFileName);
Status = ElfrBackupELFW(pLog->BindingHandle,
pLog->LogHandle,
&BackupFileName);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -119,9 +117,8 @@ BackupEventLogW(
* ClearEventLogA [ADVAPI32.@] * ClearEventLogA [ADVAPI32.@]
*/ */
BOOL WINAPI BOOL WINAPI
ClearEventLogA( ClearEventLogA(IN HANDLE hEventLog,
IN HANDLE hEventLog, IN LPCSTR lpBackupFileName)
IN LPCSTR lpBackupFileName)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -139,16 +136,16 @@ ClearEventLogA(
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
} }
Status = ElfrClearELFA(
pLog->BindingHandle,
pLog->LogHandle,
&BackupFileName);
Status = ElfrClearELFA(pLog->BindingHandle,
pLog->LogHandle,
&BackupFileName);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -157,9 +154,8 @@ ClearEventLogA(
* ClearEventLogW [ADVAPI32.@] * ClearEventLogW [ADVAPI32.@]
*/ */
BOOL WINAPI BOOL WINAPI
ClearEventLogW( ClearEventLogW(IN HANDLE hEventLog,
IN HANDLE hEventLog, IN LPCWSTR lpBackupFileName)
IN LPCWSTR lpBackupFileName)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -177,16 +173,16 @@ ClearEventLogW(
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
} }
Status = ElfrClearELFW(
pLog->BindingHandle,
pLog->LogHandle,
&BackupFileName);
Status = ElfrClearELFW(pLog->BindingHandle,
pLog->LogHandle,
&BackupFileName);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -195,8 +191,7 @@ ClearEventLogW(
* CloseEventLog [ADVAPI32.@] * CloseEventLog [ADVAPI32.@]
*/ */
BOOL WINAPI BOOL WINAPI
CloseEventLog( CloseEventLog(IN HANDLE hEventLog)
IN HANDLE hEventLog)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -217,9 +212,8 @@ CloseEventLog(
} }
else else
{ {
Status = ElfrCloseEL( Status = ElfrCloseEL(pLog->BindingHandle,
pLog->BindingHandle, &pLog->LogHandle);
&pLog->LogHandle);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
@ -243,8 +237,7 @@ CloseEventLog(
* RETURNS STD * RETURNS STD
*/ */
BOOL WINAPI BOOL WINAPI
DeregisterEventSource( DeregisterEventSource(IN HANDLE hEventLog)
IN HANDLE hEventLog)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -255,14 +248,14 @@ DeregisterEventSource(
if (!pLog) if (!pLog)
return TRUE; return TRUE;
Status = ElfrDeregisterEventSource( Status = ElfrDeregisterEventSource(pLog->BindingHandle,
pLog->BindingHandle, &pLog->LogHandle);
&pLog->LogHandle);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -275,9 +268,8 @@ DeregisterEventSource(
* NumberOfRecords [] * NumberOfRecords []
*/ */
BOOL WINAPI BOOL WINAPI
GetNumberOfEventLogRecords( GetNumberOfEventLogRecords(IN HANDLE hEventLog,
IN HANDLE hEventLog, OUT PDWORD NumberOfRecords)
OUT PDWORD NumberOfRecords)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -291,10 +283,10 @@ GetNumberOfEventLogRecords(
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
} }
Status = ElfrNumberOfRecords(
pLog->BindingHandle, Status = ElfrNumberOfRecords(pLog->BindingHandle,
pLog->LogHandle, pLog->LogHandle,
&Records); &Records);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
@ -302,6 +294,7 @@ GetNumberOfEventLogRecords(
} }
*NumberOfRecords = Records; *NumberOfRecords = Records;
return TRUE; return TRUE;
} }
@ -314,9 +307,8 @@ GetNumberOfEventLogRecords(
* OldestRecord [] * OldestRecord []
*/ */
BOOL WINAPI BOOL WINAPI
GetOldestEventLogRecord( GetOldestEventLogRecord(IN HANDLE hEventLog,
IN HANDLE hEventLog, OUT PDWORD OldestRecord)
OUT PDWORD OldestRecord)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -330,10 +322,10 @@ GetOldestEventLogRecord(
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
} }
Status = ElfrOldestRecord(
pLog->BindingHandle, Status = ElfrOldestRecord(pLog->BindingHandle,
pLog->LogHandle, pLog->LogHandle,
&Oldest); &Oldest);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
@ -341,6 +333,7 @@ GetOldestEventLogRecord(
} }
*OldestRecord = Oldest; *OldestRecord = Oldest;
return TRUE; return TRUE;
} }
@ -353,9 +346,8 @@ GetOldestEventLogRecord(
* hEvent [] * hEvent []
*/ */
BOOL WINAPI BOOL WINAPI
NotifyChangeEventLog( NotifyChangeEventLog(IN HANDLE hEventLog,
IN HANDLE hEventLog, IN HANDLE hEvent)
IN HANDLE hEvent)
{ {
/* Use ElfrChangeNotify */ /* Use ElfrChangeNotify */
UNIMPLEMENTED; UNIMPLEMENTED;
@ -368,9 +360,8 @@ NotifyChangeEventLog(
* OpenBackupEventLogA [ADVAPI32.@] * OpenBackupEventLogA [ADVAPI32.@]
*/ */
HANDLE WINAPI HANDLE WINAPI
OpenBackupEventLogA( OpenBackupEventLogA(IN LPCSTR lpUNCServerName,
IN LPCSTR lpUNCServerName, IN LPCSTR lpFileName)
IN LPCSTR lpFileName)
{ {
UNICODE_STRING UNCServerName; UNICODE_STRING UNCServerName;
UNICODE_STRING FileName; UNICODE_STRING FileName;
@ -383,6 +374,7 @@ OpenBackupEventLogA(
SetLastError(ERROR_NOT_ENOUGH_MEMORY); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL; return NULL;
} }
if (!RtlCreateUnicodeStringFromAsciiz(&FileName, lpFileName)) if (!RtlCreateUnicodeStringFromAsciiz(&FileName, lpFileName))
{ {
RtlFreeUnicodeString(&UNCServerName); RtlFreeUnicodeString(&UNCServerName);
@ -390,9 +382,8 @@ OpenBackupEventLogA(
return NULL; return NULL;
} }
Handle = OpenBackupEventLogW( Handle = OpenBackupEventLogW(UNCServerName.Buffer,
UNCServerName.Buffer, FileName.Buffer);
FileName.Buffer);
RtlFreeUnicodeString(&UNCServerName); RtlFreeUnicodeString(&UNCServerName);
RtlFreeUnicodeString(&FileName); RtlFreeUnicodeString(&FileName);
@ -409,9 +400,8 @@ OpenBackupEventLogA(
* lpFileName [] * lpFileName []
*/ */
HANDLE WINAPI HANDLE WINAPI
OpenBackupEventLogW( OpenBackupEventLogW(IN LPCWSTR lpUNCServerName,
IN LPCWSTR lpUNCServerName, IN LPCWSTR lpFileName)
IN LPCWSTR lpFileName)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -429,6 +419,7 @@ OpenBackupEventLogW(
SetLastError(ERROR_NOT_ENOUGH_MEMORY); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL; return NULL;
} }
ZeroMemory(pLog, sizeof(LOG_INFO)); ZeroMemory(pLog, sizeof(LOG_INFO));
if (lpUNCServerName == NULL || *lpUNCServerName == 0) if (lpUNCServerName == NULL || *lpUNCServerName == 0)
@ -454,20 +445,19 @@ OpenBackupEventLogW(
} }
} }
Status = ElfrOpenBELW( Status = ElfrOpenBELW(pLog->BindingHandle,
pLog->BindingHandle, (LPWSTR)lpUNCServerName,
(LPWSTR)lpUNCServerName, &FileName,
&FileName, 0,
0, 0,
0, &pLog->LogHandle);
&pLog->LogHandle);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
HeapFree(GetProcessHeap(), 0, pLog); HeapFree(GetProcessHeap(), 0, pLog);
return NULL; return NULL;
} }
return pLog; return pLog;
} }
@ -476,9 +466,8 @@ OpenBackupEventLogW(
* OpenEventLogA [ADVAPI32.@] * OpenEventLogA [ADVAPI32.@]
*/ */
HANDLE WINAPI HANDLE WINAPI
OpenEventLogA( OpenEventLogA(IN LPCSTR lpUNCServerName,
IN LPCSTR lpUNCServerName, IN LPCSTR lpSourceName)
IN LPCSTR lpSourceName)
{ {
UNICODE_STRING UNCServerName; UNICODE_STRING UNCServerName;
UNICODE_STRING SourceName; UNICODE_STRING SourceName;
@ -489,6 +478,7 @@ OpenEventLogA(
SetLastError(ERROR_NOT_ENOUGH_MEMORY); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL; return NULL;
} }
if (!RtlCreateUnicodeStringFromAsciiz(&SourceName, lpSourceName)) if (!RtlCreateUnicodeStringFromAsciiz(&SourceName, lpSourceName))
{ {
RtlFreeUnicodeString(&UNCServerName); RtlFreeUnicodeString(&UNCServerName);
@ -496,7 +486,8 @@ OpenEventLogA(
return NULL; return NULL;
} }
Handle = OpenEventLogW(UNCServerName.Buffer, SourceName.Buffer); Handle = OpenEventLogW(UNCServerName.Buffer,
SourceName.Buffer);
RtlFreeUnicodeString(&UNCServerName); RtlFreeUnicodeString(&UNCServerName);
RtlFreeUnicodeString(&SourceName); RtlFreeUnicodeString(&SourceName);
@ -513,9 +504,8 @@ OpenEventLogA(
* lpSourceName [] * lpSourceName []
*/ */
HANDLE WINAPI HANDLE WINAPI
OpenEventLogW( OpenEventLogW(IN LPCWSTR lpUNCServerName,
IN LPCWSTR lpUNCServerName, IN LPCWSTR lpSourceName)
IN LPCWSTR lpSourceName)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -533,6 +523,7 @@ OpenEventLogW(
SetLastError(ERROR_NOT_ENOUGH_MEMORY); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL; return NULL;
} }
ZeroMemory(pLog, sizeof(LOG_INFO)); ZeroMemory(pLog, sizeof(LOG_INFO));
if (lpUNCServerName == NULL || *lpUNCServerName == 0) if (lpUNCServerName == NULL || *lpUNCServerName == 0)
@ -558,21 +549,20 @@ OpenEventLogW(
} }
} }
Status = ElfrOpenELW( Status = ElfrOpenELW(pLog->BindingHandle,
pLog->BindingHandle, (LPWSTR)lpUNCServerName,
(LPWSTR)lpUNCServerName, &SourceName,
&SourceName, &EmptyString,
&EmptyString, 0,
0, 0,
0, &pLog->LogHandle);
&pLog->LogHandle);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
HeapFree(GetProcessHeap(), 0, pLog); HeapFree(GetProcessHeap(), 0, pLog);
return NULL; return NULL;
} }
return pLog; return pLog;
} }
@ -581,14 +571,13 @@ OpenEventLogW(
* ReadEventLogA [ADVAPI32.@] * ReadEventLogA [ADVAPI32.@]
*/ */
BOOL WINAPI BOOL WINAPI
ReadEventLogA( ReadEventLogA(IN HANDLE hEventLog,
IN HANDLE hEventLog, IN DWORD dwReadFlags,
IN DWORD dwReadFlags, IN DWORD dwRecordOffset,
IN DWORD dwRecordOffset, OUT LPVOID lpBuffer,
OUT LPVOID lpBuffer, IN DWORD nNumberOfBytesToRead,
IN DWORD nNumberOfBytesToRead, OUT DWORD *pnBytesRead,
OUT DWORD *pnBytesRead, OUT DWORD *pnMinNumberOfBytesNeeded)
OUT DWORD *pnMinNumberOfBytesNeeded)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -604,15 +593,15 @@ ReadEventLogA(
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
} }
Status = ElfrReadELA(
pLog->BindingHandle, Status = ElfrReadELA(pLog->BindingHandle,
pLog->LogHandle, pLog->LogHandle,
dwReadFlags, dwReadFlags,
dwRecordOffset, dwRecordOffset,
nNumberOfBytesToRead, nNumberOfBytesToRead,
lpBuffer, lpBuffer,
&bytesRead, &bytesRead,
&minNumberOfBytesNeeded); &minNumberOfBytesNeeded);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
@ -621,6 +610,7 @@ ReadEventLogA(
*pnBytesRead = (DWORD)bytesRead; *pnBytesRead = (DWORD)bytesRead;
*pnMinNumberOfBytesNeeded = (DWORD)minNumberOfBytesNeeded; *pnMinNumberOfBytesNeeded = (DWORD)minNumberOfBytesNeeded;
return TRUE; return TRUE;
} }
@ -638,14 +628,13 @@ ReadEventLogA(
* pnMinNumberOfBytesNeeded [] * pnMinNumberOfBytesNeeded []
*/ */
BOOL WINAPI BOOL WINAPI
ReadEventLogW( ReadEventLogW(IN HANDLE hEventLog,
IN HANDLE hEventLog, IN DWORD dwReadFlags,
IN DWORD dwReadFlags, IN DWORD dwRecordOffset,
IN DWORD dwRecordOffset, OUT LPVOID lpBuffer,
OUT LPVOID lpBuffer, IN DWORD nNumberOfBytesToRead,
IN DWORD nNumberOfBytesToRead, OUT DWORD *pnBytesRead,
OUT DWORD *pnBytesRead, OUT DWORD *pnMinNumberOfBytesNeeded)
OUT DWORD *pnMinNumberOfBytesNeeded)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -661,15 +650,15 @@ ReadEventLogW(
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return FALSE;
} }
Status = ElfrReadELW(
pLog->BindingHandle, Status = ElfrReadELW(pLog->BindingHandle,
pLog->LogHandle, pLog->LogHandle,
dwReadFlags, dwReadFlags,
dwRecordOffset, dwRecordOffset,
nNumberOfBytesToRead, nNumberOfBytesToRead,
lpBuffer, lpBuffer,
&bytesRead, &bytesRead,
&minNumberOfBytesNeeded); &minNumberOfBytesNeeded);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
@ -678,6 +667,7 @@ ReadEventLogW(
*pnBytesRead = (DWORD)bytesRead; *pnBytesRead = (DWORD)bytesRead;
*pnMinNumberOfBytesNeeded = (DWORD)minNumberOfBytesNeeded; *pnMinNumberOfBytesNeeded = (DWORD)minNumberOfBytesNeeded;
return TRUE; return TRUE;
} }
@ -686,9 +676,8 @@ ReadEventLogW(
* RegisterEventSourceA [ADVAPI32.@] * RegisterEventSourceA [ADVAPI32.@]
*/ */
HANDLE WINAPI HANDLE WINAPI
RegisterEventSourceA( RegisterEventSourceA(IN LPCSTR lpUNCServerName,
IN LPCSTR lpUNCServerName, IN LPCSTR lpSourceName)
IN LPCSTR lpSourceName)
{ {
UNICODE_STRING UNCServerName; UNICODE_STRING UNCServerName;
UNICODE_STRING SourceName; UNICODE_STRING SourceName;
@ -701,6 +690,7 @@ RegisterEventSourceA(
SetLastError(ERROR_NOT_ENOUGH_MEMORY); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL; return NULL;
} }
if (!RtlCreateUnicodeStringFromAsciiz(&SourceName, lpSourceName)) if (!RtlCreateUnicodeStringFromAsciiz(&SourceName, lpSourceName))
{ {
RtlFreeUnicodeString(&UNCServerName); RtlFreeUnicodeString(&UNCServerName);
@ -708,7 +698,8 @@ RegisterEventSourceA(
return NULL; return NULL;
} }
Handle = RegisterEventSourceW(UNCServerName.Buffer, SourceName.Buffer); Handle = RegisterEventSourceW(UNCServerName.Buffer,
SourceName.Buffer);
RtlFreeUnicodeString(&UNCServerName); RtlFreeUnicodeString(&UNCServerName);
RtlFreeUnicodeString(&SourceName); RtlFreeUnicodeString(&SourceName);
@ -730,9 +721,8 @@ RegisterEventSourceA(
* Failure: NULL * Failure: NULL
*/ */
HANDLE WINAPI HANDLE WINAPI
RegisterEventSourceW( RegisterEventSourceW(IN LPCWSTR lpUNCServerName,
IN LPCWSTR lpUNCServerName, IN LPCWSTR lpSourceName)
IN LPCWSTR lpSourceName)
{ {
PLOG_INFO pLog; PLOG_INFO pLog;
NTSTATUS Status; NTSTATUS Status;
@ -750,6 +740,7 @@ RegisterEventSourceW(
SetLastError(ERROR_NOT_ENOUGH_MEMORY); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL; return NULL;
} }
ZeroMemory(pLog, sizeof(LOG_INFO)); ZeroMemory(pLog, sizeof(LOG_INFO));
if (lpUNCServerName == NULL || *lpUNCServerName == 0) if (lpUNCServerName == NULL || *lpUNCServerName == 0)
@ -775,21 +766,20 @@ RegisterEventSourceW(
} }
} }
Status = ElfrRegisterEventSourceW( Status = ElfrRegisterEventSourceW(pLog->BindingHandle,
pLog->BindingHandle, (LPWSTR)lpUNCServerName,
(LPWSTR)lpUNCServerName, &SourceName,
&SourceName, &EmptyString,
&EmptyString, 0,
0, 0,
0, &pLog->LogHandle);
&pLog->LogHandle);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
HeapFree(GetProcessHeap(), 0, pLog); HeapFree(GetProcessHeap(), 0, pLog);
return NULL; return NULL;
} }
return pLog; return pLog;
} }
@ -798,16 +788,15 @@ RegisterEventSourceW(
* ReportEventA [ADVAPI32.@] * ReportEventA [ADVAPI32.@]
*/ */
BOOL WINAPI BOOL WINAPI
ReportEventA( ReportEventA(IN HANDLE hEventLog,
IN HANDLE hEventLog, IN WORD wType,
IN WORD wType, IN WORD wCategory,
IN WORD wCategory, IN DWORD dwEventID,
IN DWORD dwEventID, IN PSID lpUserSid,
IN PSID lpUserSid, IN WORD wNumStrings,
IN WORD wNumStrings, IN DWORD dwDataSize,
IN DWORD dwDataSize, IN LPCSTR *lpStrings,
IN LPCSTR *lpStrings, IN LPVOID lpRawData)
IN LPVOID lpRawData)
{ {
LPCWSTR *wideStrArray; LPCWSTR *wideStrArray;
UNICODE_STRING str; UNICODE_STRING str;
@ -820,10 +809,9 @@ ReportEventA(
if (lpStrings == NULL) if (lpStrings == NULL)
return TRUE; return TRUE;
wideStrArray = HeapAlloc( wideStrArray = HeapAlloc(GetProcessHeap(),
GetProcessHeap(), HEAP_ZERO_MEMORY,
HEAP_ZERO_MEMORY, sizeof(LPCWSTR) * wNumStrings);
sizeof(LPCWSTR) * wNumStrings);
for (i = 0; i < wNumStrings; i++) for (i = 0; i < wNumStrings; i++)
{ {
@ -834,16 +822,15 @@ ReportEventA(
if (i == wNumStrings) if (i == wNumStrings)
{ {
ret = ReportEventW( ret = ReportEventW(hEventLog,
hEventLog, wType,
wType, wCategory,
wCategory, dwEventID,
dwEventID, lpUserSid,
lpUserSid, wNumStrings,
wNumStrings, dwDataSize,
dwDataSize, wideStrArray,
wideStrArray, lpRawData);
lpRawData);
} }
else else
{ {
@ -855,17 +842,15 @@ ReportEventA(
{ {
if (wideStrArray[i]) if (wideStrArray[i])
{ {
HeapFree( HeapFree(GetProcessHeap(),
GetProcessHeap(), 0,
0, (PVOID)wideStrArray[i]);
(PVOID)wideStrArray[i]);
} }
} }
HeapFree( HeapFree(GetProcessHeap(),
GetProcessHeap(), 0,
0, wideStrArray);
wideStrArray);
return ret; return ret;
} }
@ -886,16 +871,15 @@ ReportEventA(
* lpRawData [] * lpRawData []
*/ */
BOOL WINAPI BOOL WINAPI
ReportEventW( ReportEventW(IN HANDLE hEventLog,
IN HANDLE hEventLog, IN WORD wType,
IN WORD wType, IN WORD wCategory,
IN WORD wCategory, IN DWORD dwEventID,
IN DWORD dwEventID, IN PSID lpUserSid,
IN PSID lpUserSid, IN WORD wNumStrings,
IN WORD wNumStrings, IN DWORD dwDataSize,
IN DWORD dwDataSize, IN LPCWSTR *lpStrings,
IN LPCWSTR *lpStrings, IN LPVOID lpRawData)
IN LPVOID lpRawData)
{ {
#if 0 #if 0
PLOG_INFO pLog; PLOG_INFO pLog;
@ -914,34 +898,33 @@ ReportEventW(
return FALSE; return FALSE;
} }
Strings = HeapAlloc( Strings = HeapAlloc(GetProcessHeap(),
GetProcessHeap(), 0,
0, wNumStrings * sizeof(UNICODE_STRING));
wNumStrings * sizeof(UNICODE_STRING));
if (!Strings) if (!Strings)
{ {
SetLastError(ERROR_NOT_ENOUGH_MEMORY); SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE; return FALSE;
} }
for (i = 0; i < wNumStrings; i++) for (i = 0; i < wNumStrings; i++)
RtlInitUnicodeString(&Strings[i], lpStrings[i]); RtlInitUnicodeString(&Strings[i], lpStrings[i]);
Status = ElfrReportEventW( Status = ElfrReportEventW(pLog->BindingHandle,
pLog->BindingHandle, pLog->LogHandle,
pLog->LogHandle, 0, /* FIXME: Time */
0, /* FIXME: Time */ wType,
wType, wCategory,
wCategory, dwEventID,
dwEventID, wNumStrings,
wNumStrings, dwDataSize,
dwDataSize, L"", /* FIXME: ComputerName */
L"", /* FIXME: ComputerName */ lpUserSid,
lpUserSid, (LPWSTR *)lpStrings, /* FIXME: should be Strings */
(LPWSTR *)lpStrings, /* FIXME: should be Strings */ lpRawData,
lpRawData, 0,
0, NULL,
NULL, NULL);
NULL);
HeapFree(GetProcessHeap(), 0, Strings); HeapFree(GetProcessHeap(), 0, Strings);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
@ -949,6 +932,7 @@ ReportEventW(
SetLastError(RtlNtStatusToDosError(Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
#else #else
int i; int i;

26
reactos/dll/win32/advapi32/token/privilege.c
View file

@ -18,25 +18,25 @@
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
PrivilegeCheck (HANDLE ClientToken, PrivilegeCheck(HANDLE ClientToken,
PPRIVILEGE_SET RequiredPrivileges, PPRIVILEGE_SET RequiredPrivileges,
LPBOOL pfResult) LPBOOL pfResult)
{ {
BOOLEAN Result; BOOLEAN Result;
NTSTATUS Status; NTSTATUS Status;
Status = NtPrivilegeCheck (ClientToken, Status = NtPrivilegeCheck(ClientToken,
RequiredPrivileges, RequiredPrivileges,
&Result); &Result);
if (!NT_SUCCESS (Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
*pfResult = (BOOL) Result; *pfResult = (BOOL)Result;
return TRUE; return TRUE;
} }
/* EOF */ /* EOF */

569
reactos/dll/win32/advapi32/token/token.c
View file

@ -17,25 +17,90 @@ WINE_DEFAULT_DEBUG_CHANNEL(advapi);
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
AdjustTokenGroups (HANDLE TokenHandle, AdjustTokenGroups(HANDLE TokenHandle,
BOOL ResetToDefault, BOOL ResetToDefault,
PTOKEN_GROUPS NewState, PTOKEN_GROUPS NewState,
DWORD BufferLength, DWORD BufferLength,
PTOKEN_GROUPS PreviousState, PTOKEN_GROUPS PreviousState,
PDWORD ReturnLength) PDWORD ReturnLength)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = NtAdjustGroupsToken (TokenHandle, Status = NtAdjustGroupsToken(TokenHandle,
ResetToDefault, ResetToDefault,
NewState, NewState,
BufferLength, BufferLength,
PreviousState, PreviousState,
(PULONG)ReturnLength); (PULONG)ReturnLength);
if (!NT_SUCCESS (Status)) if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
}
return TRUE;
}
/*
* @implemented
*/
BOOL STDCALL
AdjustTokenPrivileges(HANDLE TokenHandle,
BOOL DisableAllPrivileges,
PTOKEN_PRIVILEGES NewState,
DWORD BufferLength,
PTOKEN_PRIVILEGES PreviousState,
PDWORD ReturnLength)
{
NTSTATUS Status;
Status = NtAdjustPrivilegesToken(TokenHandle,
DisableAllPrivileges,
NewState,
BufferLength,
PreviousState,
(PULONG)ReturnLength);
if (STATUS_NOT_ALL_ASSIGNED == Status)
{
SetLastError(ERROR_NOT_ALL_ASSIGNED);
return TRUE;
}
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
}
/* AdjustTokenPrivileges is documented to do this */
SetLastError(ERROR_SUCCESS);
return TRUE;
}
/*
* @implemented
*/
BOOL STDCALL
GetTokenInformation(HANDLE TokenHandle,
TOKEN_INFORMATION_CLASS TokenInformationClass,
LPVOID TokenInformation,
DWORD TokenInformationLength,
PDWORD ReturnLength)
{
NTSTATUS Status;
Status = NtQueryInformationToken(TokenHandle,
TokenInformationClass,
TokenInformation,
TokenInformationLength,
(PULONG)ReturnLength);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
} }
return TRUE; return TRUE;
@ -46,34 +111,24 @@ AdjustTokenGroups (HANDLE TokenHandle,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
AdjustTokenPrivileges (HANDLE TokenHandle, SetTokenInformation(HANDLE TokenHandle,
BOOL DisableAllPrivileges, TOKEN_INFORMATION_CLASS TokenInformationClass,
PTOKEN_PRIVILEGES NewState, LPVOID TokenInformation,
DWORD BufferLength, DWORD TokenInformationLength)
PTOKEN_PRIVILEGES PreviousState,
PDWORD ReturnLength)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = NtAdjustPrivilegesToken (TokenHandle, Status = NtSetInformationToken(TokenHandle,
DisableAllPrivileges, TokenInformationClass,
NewState, TokenInformation,
BufferLength, TokenInformationLength);
PreviousState, if (!NT_SUCCESS(Status))
(PULONG)ReturnLength);
if (STATUS_NOT_ALL_ASSIGNED == Status)
{ {
SetLastError(ERROR_NOT_ALL_ASSIGNED); SetLastError(RtlNtStatusToDosError(Status));
return TRUE; return FALSE;
}
if (! NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
} }
SetLastError(ERROR_SUCCESS); /* AdjustTokenPrivileges is documented to do this */ return TRUE;
return TRUE;
} }
@ -81,26 +136,42 @@ AdjustTokenPrivileges (HANDLE TokenHandle,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
GetTokenInformation (HANDLE TokenHandle, AccessCheck(PSECURITY_DESCRIPTOR pSecurityDescriptor,
TOKEN_INFORMATION_CLASS TokenInformationClass, HANDLE ClientToken,
LPVOID TokenInformation, DWORD DesiredAccess,
DWORD TokenInformationLength, PGENERIC_MAPPING GenericMapping,
PDWORD ReturnLength) PPRIVILEGE_SET PrivilegeSet,
LPDWORD PrivilegeSetLength,
LPDWORD GrantedAccess,
LPBOOL AccessStatus)
{ {
NTSTATUS Status; NTSTATUS Status;
NTSTATUS AccessStat;
Status = NtQueryInformationToken (TokenHandle, Status = NtAccessCheck(pSecurityDescriptor,
TokenInformationClass, ClientToken,
TokenInformation, DesiredAccess,
TokenInformationLength, GenericMapping,
(PULONG)ReturnLength); PrivilegeSet,
if (!NT_SUCCESS (Status)) (PULONG)PrivilegeSetLength,
(PACCESS_MASK)GrantedAccess,
&AccessStat);
if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; if (!NT_SUCCESS(AccessStat))
{
SetLastError(RtlNtStatusToDosError(Status));
*AccessStatus = FALSE;
return TRUE;
}
*AccessStatus = TRUE;
return TRUE;
} }
@ -108,115 +179,22 @@ GetTokenInformation (HANDLE TokenHandle,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
SetTokenInformation (HANDLE TokenHandle, OpenProcessToken(HANDLE ProcessHandle,
TOKEN_INFORMATION_CLASS TokenInformationClass,
LPVOID TokenInformation,
DWORD TokenInformationLength)
{
NTSTATUS Status;
Status = NtSetInformationToken (TokenHandle,
TokenInformationClass,
TokenInformation,
TokenInformationLength);
if (!NT_SUCCESS (Status))
{
SetLastError (RtlNtStatusToDosError (Status));
return FALSE;
}
return TRUE;
}
/*
* @implemented
*/
BOOL STDCALL
AccessCheck (PSECURITY_DESCRIPTOR pSecurityDescriptor,
HANDLE ClientToken,
DWORD DesiredAccess,
PGENERIC_MAPPING GenericMapping,
PPRIVILEGE_SET PrivilegeSet,
LPDWORD PrivilegeSetLength,
LPDWORD GrantedAccess,
LPBOOL AccessStatus)
{
NTSTATUS Status;
NTSTATUS AccessStat;
Status = NtAccessCheck (pSecurityDescriptor,
ClientToken,
DesiredAccess,
GenericMapping,
PrivilegeSet,
(PULONG)PrivilegeSetLength,
(PACCESS_MASK)GrantedAccess,
&AccessStat);
if (!NT_SUCCESS (Status))
{
SetLastError (RtlNtStatusToDosError (Status));
return FALSE;
}
if (!NT_SUCCESS (AccessStat))
{
SetLastError (RtlNtStatusToDosError (Status));
*AccessStatus = FALSE;
return TRUE;
}
*AccessStatus = TRUE;
return TRUE;
}
/*
* @implemented
*/
BOOL STDCALL
OpenProcessToken (HANDLE ProcessHandle,
DWORD DesiredAccess,
PHANDLE TokenHandle)
{
NTSTATUS Status;
Status = NtOpenProcessToken (ProcessHandle,
DesiredAccess,
TokenHandle);
if (!NT_SUCCESS (Status))
{
SetLastError (RtlNtStatusToDosError (Status));
return FALSE;
}
return TRUE;
}
/*
* @implemented
*/
BOOL STDCALL
OpenThreadToken (HANDLE ThreadHandle,
DWORD DesiredAccess, DWORD DesiredAccess,
BOOL OpenAsSelf,
PHANDLE TokenHandle) PHANDLE TokenHandle)
{ {
NTSTATUS Status; NTSTATUS Status;
Status = NtOpenThreadToken (ThreadHandle, Status = NtOpenProcessToken(ProcessHandle,
DesiredAccess, DesiredAccess,
OpenAsSelf, TokenHandle);
TokenHandle); if (!NT_SUCCESS(Status))
if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -224,25 +202,24 @@ OpenThreadToken (HANDLE ThreadHandle,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
SetThreadToken (IN PHANDLE ThreadHandle OPTIONAL, OpenThreadToken(HANDLE ThreadHandle,
IN HANDLE TokenHandle) DWORD DesiredAccess,
BOOL OpenAsSelf,
PHANDLE TokenHandle)
{ {
NTSTATUS Status; NTSTATUS Status;
HANDLE hThread;
hThread = ((ThreadHandle != NULL) ? *ThreadHandle : NtCurrentThread()); Status = NtOpenThreadToken(ThreadHandle,
DesiredAccess,
Status = NtSetInformationThread (hThread, OpenAsSelf,
ThreadImpersonationToken, TokenHandle);
&TokenHandle, if (!NT_SUCCESS(Status))
sizeof(HANDLE));
if (!NT_SUCCESS(Status))
{ {
SetLastError (RtlNtStatusToDosError (Status)); SetLastError(RtlNtStatusToDosError(Status));
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -250,54 +227,25 @@ SetThreadToken (IN PHANDLE ThreadHandle OPTIONAL,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
DuplicateTokenEx (IN HANDLE ExistingTokenHandle, SetThreadToken(IN PHANDLE ThreadHandle OPTIONAL,
IN DWORD dwDesiredAccess, IN HANDLE TokenHandle)
IN LPSECURITY_ATTRIBUTES lpTokenAttributes OPTIONAL,
IN SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
IN TOKEN_TYPE TokenType,
OUT PHANDLE DuplicateTokenHandle)
{ {
OBJECT_ATTRIBUTES ObjectAttributes; NTSTATUS Status;
NTSTATUS Status; HANDLE hThread;
SECURITY_QUALITY_OF_SERVICE Sqos;
Sqos.Length = sizeof(SECURITY_QUALITY_OF_SERVICE); hThread = (ThreadHandle != NULL) ? *ThreadHandle : NtCurrentThread();
Sqos.ImpersonationLevel = ImpersonationLevel;
Sqos.ContextTrackingMode = 0;
Sqos.EffectiveOnly = FALSE;
if (lpTokenAttributes != NULL) Status = NtSetInformationThread(hThread,
ThreadImpersonationToken,
&TokenHandle,
sizeof(HANDLE));
if (!NT_SUCCESS(Status))
{ {
InitializeObjectAttributes(&ObjectAttributes, SetLastError(RtlNtStatusToDosError(Status));
NULL, return FALSE;
lpTokenAttributes->bInheritHandle ? OBJ_INHERIT : 0,
NULL,
lpTokenAttributes->lpSecurityDescriptor);
}
else
{
InitializeObjectAttributes(&ObjectAttributes,
NULL,
0,
NULL,
NULL);
} }
ObjectAttributes.SecurityQualityOfService = &Sqos; return TRUE;
Status = NtDuplicateToken (ExistingTokenHandle,
dwDesiredAccess,
&ObjectAttributes,
FALSE,
TokenType,
DuplicateTokenHandle);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
}
return TRUE;
} }
@ -305,16 +253,71 @@ DuplicateTokenEx (IN HANDLE ExistingTokenHandle,
* @implemented * @implemented
*/ */
BOOL STDCALL BOOL STDCALL
DuplicateToken (IN HANDLE ExistingTokenHandle, DuplicateTokenEx(IN HANDLE ExistingTokenHandle,
IN SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, IN DWORD dwDesiredAccess,
OUT PHANDLE DuplicateTokenHandle) IN LPSECURITY_ATTRIBUTES lpTokenAttributes OPTIONAL,
IN SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
IN TOKEN_TYPE TokenType,
OUT PHANDLE DuplicateTokenHandle)
{ {
return DuplicateTokenEx (ExistingTokenHandle, OBJECT_ATTRIBUTES ObjectAttributes;
TOKEN_IMPERSONATE | TOKEN_QUERY, NTSTATUS Status;
NULL, SECURITY_QUALITY_OF_SERVICE Sqos;
ImpersonationLevel,
TokenImpersonation, Sqos.Length = sizeof(SECURITY_QUALITY_OF_SERVICE);
DuplicateTokenHandle); Sqos.ImpersonationLevel = ImpersonationLevel;
Sqos.ContextTrackingMode = 0;
Sqos.EffectiveOnly = FALSE;
if (lpTokenAttributes != NULL)
{
InitializeObjectAttributes(&ObjectAttributes,
NULL,
lpTokenAttributes->bInheritHandle ? OBJ_INHERIT : 0,
NULL,
lpTokenAttributes->lpSecurityDescriptor);
}
else
{
InitializeObjectAttributes(&ObjectAttributes,
NULL,
0,
NULL,
NULL);
}
ObjectAttributes.SecurityQualityOfService = &Sqos;
Status = NtDuplicateToken(ExistingTokenHandle,
dwDesiredAccess,
&ObjectAttributes,
FALSE,
TokenType,
DuplicateTokenHandle);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
}
return TRUE;
}
/*
* @implemented
*/
BOOL STDCALL
DuplicateToken(IN HANDLE ExistingTokenHandle,
IN SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
OUT PHANDLE DuplicateTokenHandle)
{
return DuplicateTokenEx(ExistingTokenHandle,
TOKEN_IMPERSONATE | TOKEN_QUERY,
NULL,
ImpersonationLevel,
TokenImpersonation,
DuplicateTokenHandle);
} }
@ -476,7 +479,6 @@ CheckTokenMembership(IN HANDLE ExistingTokenHandle,
&PrivBufferSize, &PrivBufferSize,
&GrantedAccess, &GrantedAccess,
&AccessStatus); &AccessStatus);
if (NT_SUCCESS(Status) && NT_SUCCESS(AccessStatus) && (GrantedAccess == 0x1)) if (NT_SUCCESS(Status) && NT_SUCCESS(AccessStatus) && (GrantedAccess == 0x1))
{ {
*IsMember = TRUE; *IsMember = TRUE;
@ -511,87 +513,83 @@ Cleanup:
BOOL STDCALL BOOL STDCALL
IsTokenRestricted(HANDLE TokenHandle) IsTokenRestricted(HANDLE TokenHandle)
{ {
ULONG RetLength; ULONG RetLength;
PTOKEN_GROUPS lpGroups; PTOKEN_GROUPS lpGroups;
NTSTATUS Status; NTSTATUS Status;
BOOL Ret = FALSE; BOOL Ret = FALSE;
/* determine the required buffer size and allocate enough memory to read the /* determine the required buffer size and allocate enough memory to read the
list of restricted SIDs */ list of restricted SIDs */
Status = NtQueryInformationToken(TokenHandle,
Status = NtQueryInformationToken(TokenHandle, TokenRestrictedSids,
TokenRestrictedSids, NULL,
NULL, 0,
0, &RetLength);
&RetLength); if (Status != STATUS_BUFFER_TOO_SMALL)
if (Status != STATUS_BUFFER_TOO_SMALL) {
{ SetLastError(RtlNtStatusToDosError(Status));
SetLastError(RtlNtStatusToDosError(Status)); return FALSE;
return FALSE; }
}
AllocAndReadRestrictedSids: AllocAndReadRestrictedSids:
lpGroups = (PTOKEN_GROUPS)HeapAlloc(GetProcessHeap(), lpGroups = (PTOKEN_GROUPS)HeapAlloc(GetProcessHeap(),
0, 0,
RetLength); RetLength);
if (lpGroups == NULL) if (lpGroups == NULL)
{ {
SetLastError(ERROR_OUTOFMEMORY); SetLastError(ERROR_OUTOFMEMORY);
return FALSE; return FALSE;
} }
/* actually read the list of the restricted SIDs */ /* actually read the list of the restricted SIDs */
Status = NtQueryInformationToken(TokenHandle,
TokenRestrictedSids,
lpGroups,
RetLength,
&RetLength);
if (NT_SUCCESS(Status))
{
Ret = (lpGroups->GroupCount != 0);
}
else if (Status == STATUS_BUFFER_TOO_SMALL)
{
/* looks like the token was modified in the meanwhile, let's just try again */
HeapFree(GetProcessHeap(),
0,
lpGroups);
Status = NtQueryInformationToken(TokenHandle, goto AllocAndReadRestrictedSids;
TokenRestrictedSids, }
lpGroups, else
RetLength, {
&RetLength); SetLastError(RtlNtStatusToDosError(Status));
if (NT_SUCCESS(Status)) }
{
Ret = (lpGroups->GroupCount != 0);
}
else if (Status == STATUS_BUFFER_TOO_SMALL)
{
/* looks like the token was modified in the meanwhile, let's just try again */
/* free allocated memory */
HeapFree(GetProcessHeap(), HeapFree(GetProcessHeap(),
0, 0,
lpGroups); lpGroups);
goto AllocAndReadRestrictedSids; return Ret;
}
else
{
SetLastError(RtlNtStatusToDosError(Status));
}
/* free allocated memory */
HeapFree(GetProcessHeap(),
0,
lpGroups);
return Ret;
} }
BOOL STDCALL BOOL STDCALL
CreateRestrictedToken( CreateRestrictedToken(HANDLE TokenHandle,
HANDLE TokenHandle, DWORD Flags,
DWORD Flags, DWORD DisableSidCount,
DWORD DisableSidCount, PSID_AND_ATTRIBUTES pSidAndAttributes,
PSID_AND_ATTRIBUTES pSidAndAttributes, DWORD DeletePrivilegeCount,
DWORD DeletePrivilegeCount, PLUID_AND_ATTRIBUTES pLUIDAndAttributes,
PLUID_AND_ATTRIBUTES pLUIDAndAttributes, DWORD RestrictedSidCount,
DWORD RestrictedSidCount, PSID_AND_ATTRIBUTES pSIDAndAttributes,
PSID_AND_ATTRIBUTES pSIDAndAttributes, PHANDLE NewTokenHandle)
PHANDLE NewTokenHandle
)
{ {
UNIMPLEMENTED; UNIMPLEMENTED;
return FALSE; return FALSE;
} }
/* /*
* @unimplemented * @unimplemented
*/ */
@ -670,6 +668,7 @@ GetSiteSidFromToken(IN HANDLE TokenHandle)
return PSiteSid; return PSiteSid;
} }
BOOL BOOL
WINAPI WINAPI
CreateProcessWithTokenW(IN HANDLE hToken, CreateProcessWithTokenW(IN HANDLE hToken,