able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/termsrv/regapi/regwin.c

1681 lines
51 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*************************************************************************
*
* regwin.c
*
* Register APIs for window stations
*
* Copyright (c) 1998 Microsoft Corporation
*
*
*************************************************************************/
/*
* Includes
*/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <ntddkbd.h>
#include <ntddmou.h>
#include <winstaw.h>
#include <regapi.h>
//
extern HKEY g_hTSPolicyKey;//handle to TS_POLICY_SUB_TREE key
extern HKEY g_hTSControlKey;//handle to REG_CONTROL_TSERVER key
/*
* External Procedures defined here
*/
LONG WINAPI RegWinStationAccessCheck( HANDLE, REGSAM );
LONG WINAPI RegWinStationEnumerateW( HANDLE, PULONG, PULONG, PWINSTATIONNAMEW, PULONG );
LONG WINAPI RegWinStationEnumerateA( HANDLE, PULONG, PULONG, PWINSTATIONNAMEA, PULONG );
LONG WINAPI RegWinStationCreateW( HANDLE, PWINSTATIONNAMEW, BOOLEAN,
PWINSTATIONCONFIG2W, ULONG );
LONG WINAPI RegWinStationCreateA( HANDLE, PWINSTATIONNAMEA, BOOLEAN,
PWINSTATIONCONFIG2A, ULONG );
LONG WINAPI RegWinStationQueryW( HANDLE, PWINSTATIONNAMEW, PWINSTATIONCONFIG2W,
ULONG, PULONG );
LONG WINAPI RegWinStationQueryA( HANDLE, PWINSTATIONNAMEA, PWINSTATIONCONFIG2A,
ULONG, PULONG );
LONG WINAPI RegWinStationDeleteW( HANDLE, PWINSTATIONNAMEW );
LONG WINAPI RegWinStationDeleteA( HANDLE, PWINSTATIONNAMEA );
LONG WINAPI RegWinStationSetSecurityW( HANDLE, PWINSTATIONNAMEW, PSECURITY_DESCRIPTOR,
ULONG );
LONG WINAPI RegWinStationSetSecurityA( HANDLE, PWINSTATIONNAMEA, PSECURITY_DESCRIPTOR,
ULONG );
LONG WINAPI RegWinStationQuerySecurityW( HANDLE, PWINSTATIONNAMEW, PSECURITY_DESCRIPTOR,
ULONG, PULONG );
LONG WINAPI RegWinStationQuerySecurityA( HANDLE, PWINSTATIONNAMEA, PSECURITY_DESCRIPTOR,
ULONG, PULONG );
LONG WINAPI RegWinStationQueryDefaultSecurity( HANDLE, PSECURITY_DESCRIPTOR,
ULONG, PULONG );
LONG WINAPI RegWinStationSetNumValueW( HANDLE, PWINSTATIONNAMEW, LPWSTR, ULONG );
LONG WINAPI RegWinStationQueryNumValueW( HANDLE, PWINSTATIONNAMEW, LPWSTR, PULONG );
LONG WINAPI
RegConsoleShadowQueryA( HANDLE hServer,
PWINSTATIONNAMEA pWinStationName,
PWDPREFIXA pWdPrefixName,
PWINSTATIONCONFIG2A pWinStationConfig,
ULONG WinStationConfigLength,
PULONG pReturnLength );
LONG WINAPI
RegConsoleShadowQueryW( HANDLE hServer,
PWINSTATIONNAMEW pWinStationName,
PWDPREFIXW pWdPrefixName,
PWINSTATIONCONFIG2W pWinStationConfig,
ULONG WinStationConfigLength,
PULONG pReturnLength );
/*
* Private Procedures defined here
*/
LONG _RegOpenWinStation( PWINSTATIONNAMEW, REGSAM, HKEY * );
LONG _RegGetWinStationSecurity( HKEY, LPWSTR, PSECURITY_DESCRIPTOR, ULONG, PULONG );
/*
* other internal Procedures used (not defined here)
*/
VOID CreateWinStaCreate( HKEY, PWINSTATIONCREATE );
VOID CreateConfig( HKEY, PWINSTATIONCONFIG );
VOID CreateWd( HKEY, PWDCONFIG );
VOID CreateCd( HKEY, PCDCONFIG );
VOID CreatePdConfig( BOOLEAN, HKEY, PPDCONFIG, ULONG );
VOID QueryWinStaCreate( HKEY, PWINSTATIONCREATE );
VOID QueryConfig( HKEY, PWINSTATIONCONFIG );
VOID QueryWd( HKEY, PWDCONFIG );
VOID QueryCd( HKEY, PCDCONFIG );
VOID QueryPdConfig( HKEY, PPDCONFIG, PULONG );
VOID UnicodeToAnsi( CHAR *, ULONG, WCHAR * );
VOID AnsiToUnicode( WCHAR *, ULONG, CHAR * );
VOID PdConfigU2A( PPDCONFIGA, PPDCONFIGW );
VOID PdConfigA2U( PPDCONFIGW, PPDCONFIGA );
VOID WdConfigU2A( PWDCONFIGA, PWDCONFIGW );
VOID WdConfigA2U( PWDCONFIGW, PWDCONFIGA );
VOID CdConfigU2A( PCDCONFIGA, PCDCONFIGW );
VOID CdConfigA2U( PCDCONFIGW, PCDCONFIGA );
VOID WinStationCreateU2A( PWINSTATIONCREATEA, PWINSTATIONCREATEW );
VOID WinStationCreateA2U( PWINSTATIONCREATEW, PWINSTATIONCREATEA );
VOID WinStationConfigU2A( PWINSTATIONCONFIGA, PWINSTATIONCONFIGW );
VOID WinStationConfigA2U( PWINSTATIONCONFIGW, PWINSTATIONCONFIGA );
VOID SetWallPaperDisabled( HKEY, BOOLEAN );
/****************************************************************************
*
* DllEntryPoint
*
* Function is called when the DLL is loaded and unloaded.
*
* ENTRY:
* hinstDLL (input)
* Handle of DLL module
*
* fdwReason (input)
* Why function was called
*
* lpvReserved (input)
* Reserved; must be NULL
*
* EXIT:
* TRUE - Success
* FALSE - Error occurred
*
****************************************************************************/
BOOL WINAPI
DllEntryPoint( HINSTANCE hinstDLL,
DWORD fdwReason,
LPVOID lpvReserved )
{
switch ( fdwReason ) {
case DLL_PROCESS_ATTACH:
break;
case DLL_PROCESS_DETACH:
if( g_hTSPolicyKey )
{
RegCloseKey(g_hTSPolicyKey);
}
if( g_hTSControlKey )
{
RegCloseKey(g_hTSControlKey);
}
break;
default:
break;
}
return( TRUE );
}
/*******************************************************************************
*
* RegWinStationAccessCheck (ANSI or UNICODE)
*
* Determines if the current user has the requested access to the
* WinStation registry.
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* samDesired (input)
* Specifies the security access mask to be used in determining access
* to the WinStation registry.
*
* EXIT:
* ERROR_SUCCESS if the user has the requested access
* other error value (most likely ERROR_ACCESS_DENIED) if the user does
* not have the requested access.
*
******************************************************************************/
LONG WINAPI
RegWinStationAccessCheck( HANDLE hServer, REGSAM samDesired )
{
LONG Status;
HKEY Handle;
/*
* Attempt to open the registry (LOCAL_MACHINE\....\Citrix\Pd)
* at the requested access level.
*/
if ( (Status = RegOpenKeyEx( HKEY_LOCAL_MACHINE, WINSTATION_REG_NAME, 0,
samDesired, &Handle )) == ERROR_SUCCESS )
RegCloseKey( Handle );
return( Status );
}
/*******************************************************************************
*
* RegWinStationEnumerateA (ANSI stub)
*
* Returns a list of configured WinStations in the registry.
*
* ENTRY:
* see RegWinStationEnumerateW
*
* EXIT:
* see RegWinStationEnumerateW, plus
*
* ERROR_NOT_ENOUGH_MEMORY - the LocalAlloc failed
*
******************************************************************************/
LONG WINAPI
RegWinStationEnumerateA( HANDLE hServer,
PULONG pIndex,
PULONG pEntries,
PWINSTATIONNAMEA pWinStationName,
PULONG pByteCount )
{
PWINSTATIONNAMEW pBuffer = NULL, pWinStationNameW;
LONG Status;
ULONG Count, ByteCountW = (*pByteCount << 1);
/*
* If the caller supplied a buffer and the length is not 0,
* allocate a corresponding (*2) buffer for UNICODE strings.
*/
if ( pWinStationName && ByteCountW )
{
if ( !(pBuffer = LocalAlloc(0, ByteCountW)) )
return ( ERROR_NOT_ENOUGH_MEMORY );
}
/*
* Enumerate WinStations
*/
pWinStationNameW = pBuffer;
Status = RegWinStationEnumerateW( hServer, pIndex, pEntries, pWinStationNameW,
&ByteCountW );
/*
* Always /2 the resultant ByteCount (whether sucessful or not).
*/
*pByteCount = (ByteCountW >> 1);
/*
* If the function completed sucessfully and caller
* (and stub) defined a buffer to copy into, perform conversion
* from UNICODE to ANSI. Note: sucessful return may have copied
* 0 items from registry (end of enumeration), denoted by *pEntries
* == 0.
*/
if ( ((Status == ERROR_SUCCESS) || (Status == ERROR_NO_MORE_ITEMS))
&& pWinStationNameW && pWinStationName ) {
for ( Count = *pEntries; Count; Count-- ) {
UnicodeToAnsi( pWinStationName, sizeof(WINSTATIONNAMEA),
pWinStationNameW );
(char*)pWinStationName += sizeof(WINSTATIONNAMEA);
(char*)pWinStationNameW += sizeof(WINSTATIONNAMEW);
}
}
/*
* If we defined a buffer, free it now, then return the status
* of the Reg...EnumerateW function call.
*/
if ( pBuffer )
LocalFree(pBuffer);
return ( Status );
}
/*******************************************************************************
*
* RegWinStationEnumerateW (UNICODE)
*
* Returns a list of configured window stations in the registry.
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pIndex (input/output)
* Specifies the subkey index for the \Citrix\WinStations subkeys in the
* registry. Should be set to 0 for the initial call, and supplied
* again (as modified by this function) for multi-call enumeration.
* pEntries (input/output)
* Points to a variable specifying the number of entries requested.
* If the number requested is 0xFFFFFFFF, the function returns as
* many entries as possible. When the function finishes successfully,
* the variable pointed to by the pEntries parameter contains the
* number of entries actually read.
* pWinStationName (input)
* Points to the buffer to receive the enumeration results, which are
* returned as an array of WINSTATIONNAME structures. If this parameter
* is NULL, then no data will be copied, but just an enumeration count
* will be made.
* pByteCount (input/output)
* Points to a variable that specifies the size, in bytes, of the
* pWinStationName parameter. If the buffer is too small to receive even
* one entry, the function returns an error code (ERROR_OUTOFMEMORY)
* and this variable receives the required size of the buffer for a
* single subkey. When the function finishes sucessfully, the variable
* pointed to by the pByteCount parameter contains the number of bytes
* actually stored in pWinStationName.
*
* EXIT:
*
* "No Error" codes:
* ERROR_SUCCESS - The enumeration completed as requested and there
* are more WinStations subkeys (WINSTATIONNAMEs) to
* be read.
* ERROR_NO_MORE_ITEMS - The enumeration completed as requested and there
* are no more WinStations subkeys (WINSTATIONNAMEs)
* to be read.
*
* "Error" codes:
* ERROR_OUTOFMEMORY - The pWinStationName buffer is too small for even
* one entry.
* ERROR_CANTOPEN - The Citrix\WinStations key can't be opened.
*
******************************************************************************/
LONG WINAPI
RegWinStationEnumerateW( HANDLE hServer,
PULONG pIndex,
PULONG pEntries,
PWINSTATIONNAMEW pWinStationName,
PULONG pByteCount )
{
LONG Status;
HKEY Handle;
ULONG Count;
ULONG i;
/*
* Get the number of names to return
*/
Count = pWinStationName ?
min( *pByteCount / sizeof(WINSTATIONNAME), *pEntries ) :
(ULONG) -1;
*pEntries = *pByteCount = 0;
/*
* Make sure buffer is big enough for at least one name
*/
if ( Count == 0 ) {
*pByteCount = sizeof(WINSTATIONNAME);
return( ERROR_OUTOFMEMORY );
}
/*
* Open registry (LOCAL_MACHINE\....\Citrix\WinStations)
*/
if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE, WINSTATION_REG_NAME, 0,
KEY_ENUMERATE_SUB_KEYS, &Handle ) != ERROR_SUCCESS ) {
goto DefaultConsole;
}
/*
* Get list of window stations
*/
for ( i = 0; i < Count; i++ ) {
WINSTATIONNAME WinStationName;
if ( (Status = RegEnumKey(Handle, *pIndex, WinStationName,
sizeof(WINSTATIONNAME)/sizeof(TCHAR) )) != ERROR_SUCCESS )
break;
/*
* If caller supplied a buffer, then copy the WinStationName
* and increment the pointer and byte count. Always increment the
* entry count and index for the next iteration.
*/
if ( pWinStationName ) {
wcscpy( pWinStationName, WinStationName );
(char*)pWinStationName += sizeof(WINSTATIONNAME);
*pByteCount += sizeof(WINSTATIONNAME);
}
(*pEntries)++;
(*pIndex)++;
}
/*
* Close registry
*/
RegCloseKey( Handle );
if ( Status == ERROR_NO_MORE_ITEMS ) {
if ( (*pEntries == 0) && (*pIndex == 0) )
goto DefaultConsole;
}
return( Status );
/*
* We come here when there are no WinStations defined.
* We return a default "Console" name (if pWinStationName isn't NULL).
*/
DefaultConsole:
if ( pWinStationName )
wcscpy( pWinStationName, L"Console" );
*pEntries = 1;
*pByteCount = sizeof(WINSTATIONNAME);
return( ERROR_NO_MORE_ITEMS );
}
/*******************************************************************************
*
* RegWinStationCreateA (ANSI stub)
*
* Creates a new WinStaton in the registry or updates an existing entry.
* (See RegWinStationCreateW)
*
* ENTRY:
* see RegWinStationCreateW
*
* EXIT:
* see RegWinStationCreateW
*
******************************************************************************/
LONG WINAPI
RegWinStationCreateA( HANDLE hServer,
PWINSTATIONNAMEA pWinStationName,
BOOLEAN bCreate,
PWINSTATIONCONFIG2A pWinStationConfig,
ULONG WinStationConfigLength )
{
WINSTATIONNAMEW WinStationNameW;
WINSTATIONCONFIG2W WinStationConfig2W;
int i;
/*
* Validate target buffer size.
*/
if ( WinStationConfigLength < sizeof(WINSTATIONCONFIG2A) )
return( ERROR_INSUFFICIENT_BUFFER );
/*
* Convert ANSI WinStationName to UNICODE.
*/
AnsiToUnicode( WinStationNameW, sizeof(WINSTATIONNAMEW), pWinStationName );
/*
* Copy WINSTATIONCONFIG2A elements to WINSTATIONCONFIG2W elements.
*/
WinStationCreateA2U( &(WinStationConfig2W.Create),
&(pWinStationConfig->Create) );
for ( i=0; i<MAX_PDCONFIG; i++ ) {
PdConfigA2U( &(WinStationConfig2W.Pd[i]),
&(pWinStationConfig->Pd[i]) );
}
WdConfigA2U( &(WinStationConfig2W.Wd),
&(pWinStationConfig->Wd) );
CdConfigA2U( &(WinStationConfig2W.Cd),
&(pWinStationConfig->Cd) );
WinStationConfigA2U( &(WinStationConfig2W.Config),
&(pWinStationConfig->Config) );
/*
* Call RegWinStationCreateW & return it's status.
*/
return ( RegWinStationCreateW( hServer, WinStationNameW, bCreate,
&WinStationConfig2W,
sizeof(WinStationConfig2W)) );
}
/*******************************************************************************
*
* RegWinStationCreateW (UNICODE)
*
* Creates a new WinStaton in the registry or updates an existing entry.
* The state of the bCreate flag determines whether this function will
* expect to create a new WinStation entry (bCreate == TRUE) or expects to
* update an existing entry (bCreate == FALSE).
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pWinStationName (input)
* Name of a new or exisiting window station in the registry.
* bCreate (input)
* TRUE if this is a creation of a new WinStation
* FALSE if this is an update to an existing WinStation
* pWinStationConfig (input)
* Pointer to a WINSTATIONCONFIG2 structure containing configuration
* information for the specified window station name.
* WinStationConfigLength (input)
* Specifies the length in bytes of the pWinStationConfig buffer.
*
* EXIT:
* ERROR_SUCCESS - no error
*
* ERROR_INSUFFICIENT_BUFFER - pWinStationConfig buffer too small
* ERROR_FILE_NOT_FOUND - can't open ...\Citrix\WinStations key
* ERROR_CANNOT_MAKE - can't create WinStation key (registry problem)
* ERROR_ALREADY_EXISTS - create; but WinStation key already present
* ERROR_CANTOPEN - update; but WinStation key could not be opened
*
******************************************************************************/
LONG WINAPI
RegWinStationCreateW( HANDLE hServer,
PWINSTATIONNAMEW pWinStationName,
BOOLEAN bCreate,
PWINSTATIONCONFIG2W pWinStationConfig,
ULONG WinStationConfigLength )
{
HKEY Handle;
HKEY Handle1;
DWORD Disp;
/*
* Validate length of buffer
*/
if ( WinStationConfigLength < sizeof(WINSTATIONCONFIG2) )
return( ERROR_INSUFFICIENT_BUFFER );
/*
* Open registry (LOCAL_MACHINE\....\Citrix\WinStations).
* If it doesn't exist, we attemp to create it.
*/
if ( RegOpenKeyEx( HKEY_LOCAL_MACHINE, WINSTATION_REG_NAME, 0,
KEY_ALL_ACCESS, &Handle1 ) != ERROR_SUCCESS &&
RegCreateKeyEx( HKEY_LOCAL_MACHINE, WINSTATION_REG_NAME, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
&Handle1, &Disp ) != ERROR_SUCCESS ) {
return( ERROR_FILE_NOT_FOUND );
}
if ( bCreate ) {
/*
* Create requested: create a registry key for the specified
* WinStation name.
*/
if ( RegCreateKeyEx( Handle1, pWinStationName, 0, NULL,
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS,
NULL, &Handle, &Disp ) != ERROR_SUCCESS ) {
RegCloseKey( Handle1 );
return( ERROR_CANNOT_MAKE );
}
/*
* If an existing key was returned instead of a new one being
* created, return error (don't update).
*/
if ( Disp != REG_CREATED_NEW_KEY ) {
RegCloseKey( Handle1 );
RegCloseKey( Handle );
return( ERROR_ALREADY_EXISTS );
}
} else {
/*
* Update requested: open the registry key for the specified
* WinStation name.
*/
if ( RegOpenKeyEx( Handle1, pWinStationName, 0, KEY_ALL_ACCESS,
&Handle ) != ERROR_SUCCESS ) {
RegCloseKey( Handle1 );
return( ERROR_CANTOPEN );
}
}
RegCloseKey( Handle1 );
/*
* Save WINSTATIONCONFIG2 Structure
*/
CreateWinStaCreate( Handle, &pWinStationConfig->Create );
CreatePdConfig( bCreate, Handle, pWinStationConfig->Pd, MAX_PDCONFIG );
CreateWd( Handle, &pWinStationConfig->Wd );
CreateCd( Handle, &pWinStationConfig->Cd );
CreateConfig( Handle, &pWinStationConfig->Config );
/*
* Close registry handle
*/
RegCloseKey( Handle );
return( ERROR_SUCCESS );
}
/*******************************************************************************
*
* RegWinStationQueryA (ANSI stub)
*
* Query configuration information of a window station in the registry.
*
* ENTRY:
* see RegWinStationQueryW
*
* EXIT:
* see RegWinStationQueryW
*
******************************************************************************/
LONG WINAPI
RegWinStationQueryA( HANDLE hServer,
PWINSTATIONNAMEA pWinStationName,
PWINSTATIONCONFIG2A pWinStationConfig,
ULONG WinStationConfigLength,
PULONG pReturnLength )
{
WINSTATIONNAMEW WinStationNameW;
WINSTATIONCONFIG2W WinStationConfig2W;
LONG Status;
ULONG ReturnLengthW;
int i;
/*
* Validate length and zero-initialize the destination
* WINSTATIONCONFIG2A structure.
*/
if ( WinStationConfigLength < sizeof(WINSTATIONCONFIG2A) )
return( ERROR_INSUFFICIENT_BUFFER );
memset(pWinStationConfig, 0, WinStationConfigLength);
/*
* Convert ANSI WinStationName to UNICODE.
*/
AnsiToUnicode( WinStationNameW, sizeof(WINSTATIONNAMEW), pWinStationName );
/*
* Query WinStation.
*/
if ( (Status = RegWinStationQueryW( hServer,
WinStationNameW,
&WinStationConfig2W,
sizeof(WINSTATIONCONFIG2W),
&ReturnLengthW)) != ERROR_SUCCESS )
return ( Status );
/*
* Copy WINSTATIONCONFIG2W elements to WINSTATIONCONFIG2A elements.
*/
WinStationCreateU2A( &(pWinStationConfig->Create),
&(WinStationConfig2W.Create) );
for ( i=0; i<MAX_PDCONFIG; i++ ) {
PdConfigU2A( &(pWinStationConfig->Pd[i]),
&(WinStationConfig2W.Pd[i]) );
}
WdConfigU2A( &(pWinStationConfig->Wd),
&(WinStationConfig2W.Wd) );
CdConfigU2A( &(pWinStationConfig->Cd),
&(WinStationConfig2W.Cd) );
WinStationConfigU2A( &(pWinStationConfig->Config),
&(WinStationConfig2W.Config) );
*pReturnLength = sizeof(WINSTATIONCONFIG2A);
return( ERROR_SUCCESS );
}
/*******************************************************************************
*
*
*
* RegWinStationQueryEx (UNICODE)
*
* USE THIS CALL if you are in TermSrv.DLL, since it will update the global policy object
*
* Same as RegWinStationQueryW with the excpetion that a pointer to a global policy object is passed in.
*
* Query configuration information of a window station in the registry.
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pMachinePolicy (input)
* pointer to a gloabl machine policy struct
* pWinStationName (input)
* Name of an exisiting window station in the registry.
* pWinStationConfig (input)
* Pointer to a WINSTATIONCONFIG2 structure that will receive
* information about the specified window station name.
* WinStationConfigLength (input)
* Specifies the length in bytes of the pWinStationConfig buffer.
* pReturnLength (output)
* Receives the number of bytes placed in the pWinStationConfig buffer.
*
* EXIT:
* ERROR_SUCCESS - no error
* otherwise: the error code
*
******************************************************************************/
LONG WINAPI
RegWinStationQueryEx( HANDLE hServer,
PPOLICY_TS_MACHINE pMachinePolicy,
PWINSTATIONNAMEW pWinStationName,
PWINSTATIONCONFIG2W pWinStationConfig,
ULONG WinStationConfigLength,
PULONG pReturnLength,
BOOLEAN bPerformMerger)
{
LONG Status;
HKEY Handle;
ULONG Count;
/*
* Validate length and zero-initialize the destination
* WINSTATIONCONFIG2W buffer.
*/
if ( WinStationConfigLength < sizeof(WINSTATIONCONFIG2) )
return( ERROR_INSUFFICIENT_BUFFER );
memset(pWinStationConfig, 0, WinStationConfigLength);
/*
* Open registry
*/
Status = _RegOpenWinStation( pWinStationName, KEY_READ, &Handle );
if ( Status )
Handle = 0;
/*
* Query WINSTATIONCONFIG2 Structure
*/
QueryWinStaCreate( Handle, &pWinStationConfig->Create );
Count = MAX_PDCONFIG;
QueryPdConfig( Handle, pWinStationConfig->Pd, &Count );
QueryWd( Handle, &pWinStationConfig->Wd );
QueryCd( Handle, &pWinStationConfig->Cd );
// This will populate the winstation's userconfig data with machine's version of that data.
QueryConfig( Handle, &pWinStationConfig->Config );
// Since we want to co-exist with the legacy path thru TSCC, we continue to call QueryConfig()
// as we have done above, however, we follow up with a call that get's data from the group policy
// tree, and then overrides the existing data (aquired above) by the specific data from group policy.
RegGetMachinePolicy( pMachinePolicy );
if (bPerformMerger)
RegMergeMachinePolicy( pMachinePolicy, &pWinStationConfig->Config.User , &pWinStationConfig->Create );
/*
* Close registry
*/
if ( Status == ERROR_SUCCESS )
RegCloseKey( Handle );
*pReturnLength = sizeof(WINSTATIONCONFIG2);
return( ERROR_SUCCESS );
}
/*******************************************************************************
*
* RegWinStationQueryW (UNICODE)
*
* Query configuration information of a window station in the registry.
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pWinStationName (input)
* Name of an exisiting window station in the registry.
* pWinStationConfig (input)
* Pointer to a WINSTATIONCONFIG2 structure that will receive
* information about the specified window station name.
* WinStationConfigLength (input)
* Specifies the length in bytes of the pWinStationConfig buffer.
* pReturnLength (output)
* Receives the number of bytes placed in the pWinStationConfig buffer.
*
* EXIT:
* ERROR_SUCCESS - no error
* otherwise: the error code
*
******************************************************************************/
LONG WINAPI
RegWinStationQueryW( HANDLE hServer,
PWINSTATIONNAMEW pWinStationName,
PWINSTATIONCONFIG2W pWinStationConfig,
ULONG WinStationConfigLength,
PULONG pReturnLength )
{
LONG Status;
HKEY Handle;
ULONG Count;
POLICY_TS_MACHINE MachinePolicy;
/*
* Validate length and zero-initialize the destination
* WINSTATIONCONFIG2W buffer.
*/
if ( WinStationConfigLength < sizeof(WINSTATIONCONFIG2) )
return( ERROR_INSUFFICIENT_BUFFER );
memset(pWinStationConfig, 0, WinStationConfigLength);
/*
* Open registry
*/
Status = _RegOpenWinStation( pWinStationName, KEY_READ, &Handle );
if ( Status )
Handle = 0;
/*
* Query WINSTATIONCONFIG2 Structure
*/
QueryWinStaCreate( Handle, &pWinStationConfig->Create );
Count = MAX_PDCONFIG;
QueryPdConfig( Handle, pWinStationConfig->Pd, &Count );
QueryWd( Handle, &pWinStationConfig->Wd );
QueryCd( Handle, &pWinStationConfig->Cd );
// This will populate the winstation's userconfig data with machine's version of that data.
QueryConfig( Handle, &pWinStationConfig->Config );
// Since we want to co-exist with the legacy path thru TSCC, we continue to call QueryConfig()
// as we have done above, however, we follow up with a call that get's data from the group policy
// tree, and then overrides the existing data (aquired above) by the specific data from group policy.
RegGetMachinePolicy( & MachinePolicy );
RegMergeMachinePolicy( & MachinePolicy, &pWinStationConfig->Config.User , &pWinStationConfig->Create );
/*
* Close registry
*/
if ( Status == ERROR_SUCCESS )
RegCloseKey( Handle );
*pReturnLength = sizeof(WINSTATIONCONFIG2);
return( ERROR_SUCCESS );
}
/*******************************************************************************
*
* RegConsoleShadowQueryA (ANSI stub)
*
* Query configuration information for the console shadow in the registry.
*
* ENTRY:
* see RegConsoleShadowQueryW
*
* EXIT:
* see RegConsoleShadowQueryW
*
******************************************************************************/
LONG WINAPI
RegConsoleShadowQueryA( HANDLE hServer,
PWINSTATIONNAMEA pWinStationName,
PWDPREFIXA pWdPrefixName,
PWINSTATIONCONFIG2A pWinStationConfig,
ULONG WinStationConfigLength,
PULONG pReturnLength )
{
WINSTATIONNAMEW WinStationNameW;
WDPREFIXW WdPrefixNameW;
WINSTATIONCONFIG2W WinStationConfig2W;
LONG Status;
ULONG ReturnLengthW;
int i;
/*
* Validate length and zero-initialize the destination
* WINSTATIONCONFIG2A structure.
*/
if ( WinStationConfigLength < sizeof(WINSTATIONCONFIG2A) )
return( ERROR_INSUFFICIENT_BUFFER );
/*
* Convert ANSI WinStationName and prefix name to UNICODE.
*/
AnsiToUnicode( WinStationNameW, sizeof(WINSTATIONNAMEW), pWinStationName );
AnsiToUnicode( WdPrefixNameW, sizeof(WDPREFIXW), pWdPrefixName );
/*
* Query WinStation.
*/
if ( (Status = RegConsoleShadowQueryW( hServer,
WinStationNameW,
WdPrefixNameW,
&WinStationConfig2W,
sizeof(WINSTATIONCONFIG2W),
&ReturnLengthW)) != ERROR_SUCCESS )
return ( Status );
/*
* Copy WINSTATIONCONFIG2W elements to WINSTATIONCONFIG2A elements.
*/
for ( i=0; i<MAX_PDCONFIG; i++ ) {
PdConfigU2A( &(pWinStationConfig->Pd[i]),
&(WinStationConfig2W.Pd[i]) );
}
WdConfigU2A( &(pWinStationConfig->Wd),
&(WinStationConfig2W.Wd) );
CdConfigU2A( &(pWinStationConfig->Cd),
&(WinStationConfig2W.Cd) );
*pReturnLength = sizeof(WINSTATIONCONFIG2A);
return( ERROR_SUCCESS );
}
/*******************************************************************************
*
* RegConsoleShadowQueryW (UNICODE)
*
* Query configuration information for the console shadow in the registry.
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pWinStationName (input)
* Name of an exisiting window station in the registry.
* pWdPrefixName (input)
* Name of the Wd prefix used to point to the sub-winstation key.
* pWinStationConfig (input)
* Pointer to a WINSTATIONCONFIG2 structure that will receive
* information about the specified window station name.
* WinStationConfigLength (input)
* Specifies the length in bytes of the pWinStationConfig buffer.
* pReturnLength (output)
* Receives the number of bytes placed in the pWinStationConfig buffer.
*
* EXIT:
* ERROR_SUCCESS - no error
* otherwise: the error code
*
******************************************************************************/
LONG WINAPI
RegConsoleShadowQueryW( HANDLE hServer,
PWINSTATIONNAMEW pWinStationName,
PWDPREFIXW pWdPrefixName,
PWINSTATIONCONFIG2W pWinStationConfig,
ULONG WinStationConfigLength,
PULONG pReturnLength )
{
LONG Status;
LONG lLength;
HKEY Handle;
ULONG Count;
WCHAR szRegName[ WINSTATIONNAME_LENGTH + WDPREFIX_LENGTH + 2 ];
/*
* Validate length and zero-initialize the destination
* WINSTATIONCONFIG2W buffer.
*/
if ( WinStationConfigLength < sizeof(WINSTATIONCONFIG2) )
return( ERROR_INSUFFICIENT_BUFFER );
/*
* Open registry
*/
wcsncpy( szRegName, pWinStationName, sizeof(szRegName)/sizeof(WCHAR) - 1 );
szRegName[sizeof(szRegName)/sizeof(WCHAR) - 1] = 0; // terminate the string even if pWinStationName is longer than the buffer
lLength = wcslen( szRegName );
if ( sizeof(szRegName)/sizeof(WCHAR) > ( lLength + 1 + wcslen( pWdPrefixName ) ) ) {
wcsncat( szRegName, L"\\", sizeof(szRegName)/sizeof(WCHAR) - lLength - 1 );
wcsncat( szRegName, pWdPrefixName, sizeof(szRegName)/sizeof(WCHAR) - lLength - 2 );
} else {
return ERROR_INVALID_PARAMETER;
}
Status = _RegOpenWinStation( szRegName, KEY_READ, &Handle );
if ( Status )
Handle = 0;
/*
* Query WINSTATIONCONFIG2 Structure
*/
Count = MAX_PDCONFIG;
QueryPdConfig( Handle, pWinStationConfig->Pd, &Count );
QueryWd( Handle, &pWinStationConfig->Wd );
QueryCd( Handle, &pWinStationConfig->Cd );
/*
* Close registry
*/
if ( Status == ERROR_SUCCESS )
RegCloseKey( Handle );
*pReturnLength = sizeof(WINSTATIONCONFIG2);
return( ERROR_SUCCESS );
}
/*******************************************************************************
*
* RegWinStationDeleteA (ANSI stub)
*
* Deletes a window station from the registry.
*
* ENTRY:
* see RegWinStationDeleteW
*
* EXIT:
* see RegWinStationDeleteW
*
******************************************************************************/
LONG WINAPI
RegWinStationDeleteA( HANDLE hServer, PWINSTATIONNAMEA pWinStationName )
{
WINSTATIONNAMEW WinStationNameW;
AnsiToUnicode( WinStationNameW, sizeof(WinStationNameW), pWinStationName );
return ( RegWinStationDeleteW ( hServer, WinStationNameW ) );
}
/*******************************************************************************
*
* RegWinStationDeleteW (UNICODE)
*
* Deletes a window station from the registry.
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pWinStationName (input)
* Name of a window station to delete from the registry.
*
* EXIT:
* ERROR_SUCCESS - no error
* otherwise: the error code
*
******************************************************************************/
LONG WINAPI
RegWinStationDeleteW( HANDLE hServer, PWINSTATIONNAMEW pWinStationName )
{
LONG Status;
HKEY Handle1, Handle2;
/*
* Open registry (LOCAL_MACHINE\....\Citrix\WinStations).
*/
if ( (Status = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
WINSTATION_REG_NAME, 0,
KEY_ALL_ACCESS, &Handle1 )
!= ERROR_SUCCESS) ) {
return( Status );
}
/*
* Open the registry key for the specified WinStation name.
*/
if ( (Status = RegOpenKeyEx( Handle1, pWinStationName, 0,
KEY_ALL_ACCESS, &Handle2 )
!= ERROR_SUCCESS) ) {
RegCloseKey( Handle1 );
return( Status );
}
SetWallPaperDisabled( Handle2, FALSE );
/*
* Close the WinStation key handle just opened (so we can delete key),
* delete the key, and close the Citrix registry handle.
*/
RegCloseKey( Handle2 );
Status = RegDeleteKey( Handle1, pWinStationName );
RegCloseKey( Handle1 );
return( Status );
}
/*******************************************************************************
*
* RegWinStationSetSecurityA (ANSI stub)
*
* Sets security info for the specified WinStation.
*
* ENTRY:
* see RegWinStationSetSecurityW
*
* EXIT:
* see RegWinStationSetSecurityW
*
******************************************************************************/
LONG WINAPI
RegWinStationSetSecurityA( HANDLE hServer,
PWINSTATIONNAMEA pWinStationName,
PSECURITY_DESCRIPTOR SecurityDescriptor,
ULONG Length )
{
WINSTATIONNAMEW WinStationNameW;
AnsiToUnicode( WinStationNameW, sizeof(WinStationNameW), pWinStationName );
return ( RegWinStationSetSecurityW( hServer, WinStationNameW,
SecurityDescriptor,
Length ) );
}
/*******************************************************************************
*
* RegWinStationSetSecurityW (UNICODE)
*
* Sets security info for the specified WinStation.
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pWinStationName (input)
* Name of a window station to set security for.
* pSecurityDescriptor (input)
* Pointer to Security Descriptor to save
* Length (input)
* Length of SecurityDescriptor above
*
* EXIT:
* ERROR_SUCCESS - no error
* otherwise: the error code
*
******************************************************************************/
LONG WINAPI
RegWinStationSetSecurityW( HANDLE hServer,
PWINSTATIONNAMEW pWinStationName,
PSECURITY_DESCRIPTOR SecurityDescriptor,
ULONG Length )
{
HKEY Handle;
ULONG SrLength;
PSECURITY_DESCRIPTOR SrSecurityDescriptor;
LONG Error;
NTSTATUS Status;
/*
* Open registry
*/
if ( Error = _RegOpenWinStation( pWinStationName, KEY_ALL_ACCESS, &Handle ) )
return( Error );
/*
* Determine buffer length needed to convert SD to self-relative format.
*/
SrLength = 0;
Status = RtlMakeSelfRelativeSD( SecurityDescriptor, NULL, &SrLength );
if ( Status != STATUS_BUFFER_TOO_SMALL ) {
RegCloseKey( Handle );
return( RtlNtStatusToDosError( Status ) );
}
/*
* Allocate buffer for self-relative SD.
*/
SrSecurityDescriptor = LocalAlloc( 0, SrLength );
if ( SrSecurityDescriptor == NULL ) {
RegCloseKey( Handle );
return( ERROR_NOT_ENOUGH_MEMORY );
}
/*
* Now convert SD to self-relative format.
*/
Status = RtlMakeSelfRelativeSD( SecurityDescriptor,
SrSecurityDescriptor, &SrLength );
if ( !NT_SUCCESS( Status ) ) {
LocalFree( SrSecurityDescriptor );
RegCloseKey( Handle );
return( RtlNtStatusToDosError( Status ) );
}
/*
* Save the security data
*/
Error = RegSetValueEx( Handle, L"Security", 0, REG_BINARY,
(BYTE *)SrSecurityDescriptor, SrLength );
/*
* Free memory used for Self-relative Security Descriptor
*/
LocalFree( SrSecurityDescriptor );
/*
* Close registry
*/
RegCloseKey( Handle );
return( Error );
}
/*******************************************************************************
*
* RegWinStationQuerySecurityA (ANSI stub)
*
* Query security info for the specified WinStation.
*
* ENTRY:
* see RegWinStationQuerySecurityW
*
* EXIT:
* see RegWinStationQuerySecurityW
*
******************************************************************************/
LONG WINAPI
RegWinStationQuerySecurityA( HANDLE hServer,
PWINSTATIONNAMEA pWinStationName,
PSECURITY_DESCRIPTOR SecurityDescriptor,
ULONG Length,
PULONG ReturnLength )
{
WINSTATIONNAMEW WinStationNameW;
AnsiToUnicode( WinStationNameW, sizeof(WinStationNameW), pWinStationName );
return ( RegWinStationQuerySecurityW( hServer, WinStationNameW,
SecurityDescriptor,
Length,
ReturnLength ) );
}
/*******************************************************************************
*
* RegWinStationQuerySecurityW (UNICODE)
*
* Query security info for the specified WinStation.
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pWinStationName (input)
* Name of a window station to query security for.
* pSecurityDescriptor (output)
* Pointer to location to return SecurityDescriptor.
* Length (input)
* Length of SecurityDescriptor buffer.
* ReturnLength (output)
* Pointer to location to return length of SecurityDescriptor returned.
*
* EXIT:
* ERROR_SUCCESS - no error
* otherwise: the error code
*
******************************************************************************/
LONG WINAPI
RegWinStationQuerySecurityW( HANDLE hServer,
PWINSTATIONNAMEW pWinStationName,
PSECURITY_DESCRIPTOR SecurityDescriptor,
ULONG Length,
PULONG ReturnLength )
{
HKEY Handle;
LONG Error;
/*
* Open registry
*/
if ( Error = _RegOpenWinStation( pWinStationName, KEY_READ, &Handle ) )
return( Error );
/*
* Call RegGetWinStationSecurity() to do all the work
*/
Error = _RegGetWinStationSecurity( Handle, L"Security",
SecurityDescriptor, Length, ReturnLength );
RegCloseKey( Handle );
return( Error );
}
/*******************************************************************************
*
* RegWinStationQueryDefaultSecurity
*
* Query default WinStation security.
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pSecurityDescriptor (output)
* Pointer to location to return SecurityDescriptor.
* Length (input)
* Length of SecurityDescriptor buffer.
* ReturnLength (output)
* Pointer to location to return length of SecurityDescriptor returned.
*
* EXIT:
* ERROR_SUCCESS - no error
* otherwise: the error code
*
******************************************************************************/
LONG WINAPI
RegWinStationQueryDefaultSecurity( HANDLE hServer,
PSECURITY_DESCRIPTOR SecurityDescriptor,
ULONG Length,
PULONG ReturnLength )
{
HKEY Handle;
LONG Error;
/*
* Open registry
*/
if ( Error = RegOpenKeyEx( HKEY_LOCAL_MACHINE, WINSTATION_REG_NAME, 0,
KEY_READ, &Handle ) )
return( Error );
/*
* Call RegGetWinStationSecurity() to do all the work
*/
Error = _RegGetWinStationSecurity( Handle, L"DefaultSecurity",
SecurityDescriptor, Length, ReturnLength );
RegCloseKey( Handle );
return( Error );
}
/*******************************************************************************
*
* RegWinStationSetNumValueW (UNICODE)
*
* Set numeric value in WinStation registry configuration
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pWinStationName (input)
* Name of a window station to modify from the registry.
* pValueName (input)
* name of registry value to set
* ValueData (input)
* data (DWORD) for registry value to set
*
* EXIT:
* ERROR_SUCCESS - no error
* otherwise: the error code
*
******************************************************************************/
LONG WINAPI
RegWinStationSetNumValueW( HANDLE hServer,
PWINSTATIONNAMEW pWinStationName,
LPWSTR pValueName,
ULONG ValueData )
{
HKEY Handle;
LONG Error;
/*
* Open registry
*/
if ( Error = _RegOpenWinStation( pWinStationName, KEY_ALL_ACCESS, &Handle ) )
return( Error );
/*
* Set the numeric value
*/
Error = RegSetValueEx( Handle, pValueName, 0, REG_DWORD,
(BYTE *)&ValueData, sizeof(DWORD) );
/*
* Close registry
*/
RegCloseKey( Handle );
return( Error );
}
/*******************************************************************************
*
* RegWinStationQueryNumValueW (UNICODE)
*
* Query numeric value from WinStation registry configuration
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pWinStationName (input)
* Name of a window station to modify from the registry.
* pValueName (input)
* name of registry value to set
* pValueData (output)
* address to return data (DWORD) value from registry
*
* EXIT:
* ERROR_SUCCESS - no error
* otherwise: the error code
*
******************************************************************************/
LONG WINAPI
RegWinStationQueryNumValueW( HANDLE hServer,
PWINSTATIONNAMEW pWinStationName,
LPWSTR pValueName,
PULONG pValueData )
{
DWORD ValueSize = sizeof(DWORD);
DWORD ValueType;
HKEY Handle;
LONG Error;
/*
* Open registry
*/
if ( Error = _RegOpenWinStation( pWinStationName, KEY_READ, &Handle ) )
return( Error );
/*
* Query the numeric value
*/
Error = RegQueryValueEx( Handle, pValueName, NULL, &ValueType,
(LPBYTE) pValueData, &ValueSize );
/*
* Close registry
*/
RegCloseKey( Handle );
return( Error );
}
/*******************************************************************************
*
* RegWinStationQueryValueW (UNICODE)
*
* Query value from WinStation registry configuration
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pWinStationName (input)
* Name of a window station to modify from the registry.
* pValueName (input)
* name of registry value to set
* pValueData (output)
* address to return data (DWORD) value from registry
* ValueSize (input)
* size of value buffer
* pValueSize (input)
* actual value size
*
* EXIT:
* ERROR_SUCCESS - no error
* otherwise: the error code
*
******************************************************************************/
LONG WINAPI
RegWinStationQueryValueW( HANDLE hServer,
PWINSTATIONNAMEW pWinStationName,
LPWSTR pValueName,
PVOID pValueData,
ULONG ValueSize,
PULONG pValueSize )
{
DWORD ValueType;
HKEY Handle;
LONG Error;
*pValueSize = ValueSize;
/*
* Open registry
*/
if ( Error = _RegOpenWinStation( pWinStationName, KEY_READ, &Handle ) )
return( Error );
/*
* Query the numeric value
*/
Error = RegQueryValueEx( Handle, pValueName, NULL, &ValueType,
(LPBYTE) pValueData, pValueSize );
/*
* Close registry
*/
RegCloseKey( Handle );
return( Error );
}
/*******************************************************************************
*
* -- private routine --
*
* _RegOpenWinStation
*
* open registry of specified winstation
*
* NOTE: handle must be closed with "RegCloseKey"
*
* ENTRY:
* hServer (input)
* Handle to WinFrame Server
* pWinStationName (input)
* Name of a window station to modify from the registry.
* samDesired (input)
* REGSAM access level for registry open.
* pHandle (output)
* address to return handle
*
* EXIT:
* ERROR_SUCCESS - no error
* otherwise: the error code
*
******************************************************************************/
LONG
_RegOpenWinStation( PWINSTATIONNAMEW pWinStationName,
REGSAM samDesired,
HKEY * pHandle )
{
HKEY Handle1;
LONG Error;
/*
* Open registry (LOCAL_MACHINE\....\Citrix\WinStations).
*/
if ( (Error = RegOpenKeyEx( HKEY_LOCAL_MACHINE, WINSTATION_REG_NAME, 0,
samDesired, &Handle1 ) != ERROR_SUCCESS) ) {
return( Error );
}
/*
* Open the registry key for the specified WinStation name.
*/
Error = RegOpenKeyEx( Handle1, pWinStationName, 0, samDesired, pHandle);
RegCloseKey( Handle1 );
return( Error );
}
/*******************************************************************************
*
* -- private routine --
*
* _RegGetWinStationSecurity
*
* Query the security descriptor from the specified registry key.
*
* ENTRY:
* Handle (input)
* Open registry key handle.
* ValueName (input)
* Name of security value.
* pSecurityDescriptor (output)
* Pointer to location to return SecurityDescriptor.
* Length (input)
* Length of SecurityDescriptor buffer.
* ReturnLength (output)
* Pointer to location to return length of SecurityDescriptor returned.
*
* EXIT:
* ERROR_SUCCESS - no error
* otherwise: the error code
*
******************************************************************************/
LONG
_RegGetWinStationSecurity( HKEY Handle,
LPWSTR ValueName,
PSECURITY_DESCRIPTOR SecurityDescriptor,
ULONG Length,
PULONG ReturnLength )
{
DWORD ValueType;
DWORD SrLength;
ULONG SdSize, DaclSize, SaclSize, OwnerSize, GroupSize;
PSECURITY_DESCRIPTOR SrSecurityDescriptor;
PACL pDacl, pSacl;
PSID pOwner, pGroup;
LONG Error;
NTSTATUS Status;
/*
* Query the length of the Security value
*/
SrLength = 0;
if ( Error = RegQueryValueEx( Handle, ValueName, NULL, &ValueType,
NULL, &SrLength ) ) {
return( Error );
}
/*
* Return error if not correct data type
*/
if ( ValueType != REG_BINARY ) {
return( ERROR_FILE_NOT_FOUND );
}
/*
* Allocate a buffer to read the Security info and read it
*/
SrSecurityDescriptor = LocalAlloc( 0, SrLength );
if ( SrSecurityDescriptor == NULL ) {
return( ERROR_NOT_ENOUGH_MEMORY );
}
if ( Error = RegQueryValueEx( Handle, ValueName, NULL, &ValueType,
SrSecurityDescriptor, &SrLength ) ) {
LocalFree( SrSecurityDescriptor );
return( Error );
}
/*
* Determine amount of space required to convert SD from
* self-relative format to absolute format.
*/
SdSize = DaclSize = SaclSize = OwnerSize = GroupSize = 0;
Status = RtlSelfRelativeToAbsoluteSD( SrSecurityDescriptor,
NULL, &SdSize,
NULL, &DaclSize,
NULL, &SaclSize,
NULL, &OwnerSize,
NULL, &GroupSize );
if ( Status != STATUS_BUFFER_TOO_SMALL ) {
LocalFree( SrSecurityDescriptor );
return( RtlNtStatusToDosError( Status ) );
}
*ReturnLength = SdSize + DaclSize + SaclSize + OwnerSize + GroupSize;
/*
* If required size is greater than callers buffer size, then return
*/
if ( *ReturnLength > Length ) {
LocalFree( SrSecurityDescriptor );
return( ERROR_INSUFFICIENT_BUFFER );
}
pDacl = (PACL)((PCHAR)SecurityDescriptor + SdSize);
pSacl = (PACL)((PCHAR)pDacl + DaclSize);
pOwner = (PSID)((PCHAR)pSacl + SaclSize);
pGroup = (PSID)((PCHAR)pOwner + OwnerSize);
/*
* Now convert self-relative SD to absolute format.
*/
Status = RtlSelfRelativeToAbsoluteSD( SrSecurityDescriptor,
SecurityDescriptor, &SdSize,
pDacl, &DaclSize,
pSacl, &SaclSize,
pOwner, &OwnerSize,
pGroup, &GroupSize );
if ( !NT_SUCCESS( Status ) )
Error = RtlNtStatusToDosError( Status );
/*
* Free memory used for Self-relative Security Descriptor
*/
LocalFree( SrSecurityDescriptor );
return( Error );
}
Reference in a new issue Copy permalink