Microsoft/Windows2003-3790
Microsoft
/
Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Windows2003-3790/termsrv/tsappcmp/objrules.c

362 lines
12 KiB
C
Raw Permalink Blame History

/*************************************************************************
* objrules.c
*
* Routines for caching registry object rules and looking up object names.
*
* Copyright (C) 1997-1999 Microsoft Corp.
*************************************************************************/
#include "precomp.h"
#pragma hdrstop
#include <objrules.h>
#include <ntverp.h>
OBJRULELIST SemaRuleList;
OBJRULELIST MutexRuleList;
OBJRULELIST SectionRuleList;
OBJRULELIST EventRuleList;
ULONG NumRuleLists;
RULEINITENTRY RuleInitTab[] =
{
{&SemaRuleList, USER_GLOBAL_SEMAPHORES, SYSTEM_GLOBAL_SEMAPHORES},
{&MutexRuleList, USER_GLOBAL_MUTEXES, SYSTEM_GLOBAL_MUTEXES},
{&SectionRuleList, USER_GLOBAL_SECTIONS, SYSTEM_GLOBAL_SECTIONS},
{&EventRuleList, USER_GLOBAL_EVENTS, SYSTEM_GLOBAL_EVENTS},
};
//*****************************************************************************
// InitRuleList
//
// Initializes an object rule list to empty.
//
// Parameters:
// POBJRULLIST (IN) - ptr to object rule list
// Return Value:
// None.
//*****************************************************************************
void InitRuleList(POBJRULELIST pObjRuleList)
{
pObjRuleList->First = (POBJRULE) NULL;
pObjRuleList->Last = (POBJRULE) NULL;
}
//*****************************************************************************
// GetMultiSzValue
//
// Retrieves the REG_MULTI_SZ value ValueName under key hKey.
//
// Parameters:
// hKey The registry key
// ValueName The registry value name (NULL Terminated)
// pValueInfo Pointer to Pointer receiving a
// PKEY_VALUE_PARTIAL_INFORMATION structure
// upon successful return. This structure
// contains the registry data and its length.
// Return Value:
// Returns TRUE if successful, otherwise FALSE.
// If successful, pValueInfo is updated with a pointer to a
// structure. The caller must free the structure.
//*****************************************************************************
BOOL GetMultiSzValue(HKEY hKey, PWSTR ValueName,
PKEY_VALUE_PARTIAL_INFORMATION *pValueInfo)
{
PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
UNICODE_STRING UniString;
ULONG BufSize;
ULONG DataLen;
NTSTATUS NtStatus;
BOOL Retried = FALSE;
// Determine the value info buffer size
BufSize = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + MAX_PATH*sizeof(WCHAR);
for (;;) {
ValueInfo = RtlAllocateHeap(RtlProcessHeap(), 0, BufSize);
if (ValueInfo)
{
RtlInitUnicodeString(&UniString, ValueName);
NtStatus = NtQueryValueKey(hKey,
&UniString,
KeyValuePartialInformation,
ValueInfo,
BufSize,
&DataLen);
if (NT_SUCCESS(NtStatus) && (REG_MULTI_SZ == ValueInfo->Type)) {
*pValueInfo = ValueInfo;
return(TRUE);
}
if (!Retried && (NtStatus == STATUS_BUFFER_OVERFLOW)) {
BufSize = DataLen;
RtlFreeHeap(RtlProcessHeap(), 0, ValueInfo);
Retried = TRUE;
continue;
}
// Key not present or other type of error
RtlFreeHeap(RtlProcessHeap(), 0, ValueInfo);
return(FALSE);
}
else
{
return(FALSE);
}
}
}
//*****************************************************************************
// AddRule
//
// Adds an object rule a rule list.
//
// Parameters:
// RuleList The rule list.
// ObjName The name of the object.
// SystemGlobalRule If true, the object is to be SYSTEM_GLOBAL.
// Return Value:
// None.
//*****************************************************************************
void AddRule(POBJRULELIST RuleList, PWSTR ObjName, BOOL SystemGlobalRule)
{
ULONG AllocSize;
ULONG Length;
POBJRULE pObjRule;
#if DBG
DbgPrint("Adding Rule: %ws SystemGlobal: %d\n",ObjName,SystemGlobalRule);
#endif
Length = wcslen(ObjName);
AllocSize = sizeof(OBJRULE) + (Length + 1) * sizeof(WCHAR);
if (pObjRule = RtlAllocateHeap(RtlProcessHeap(), 0, AllocSize)) {
wcscpy(pObjRule->ObjName, ObjName);
pObjRule->SystemGlobal = SystemGlobalRule;
if (ObjName[Length-1] == L'*') {
pObjRule->WildCard = TRUE;
pObjRule->MatchLen = Length - 1;
// Insert rule at the end of the list
pObjRule->Next = NULL;
if (RuleList->First == NULL) {
RuleList->First = RuleList->Last = pObjRule;
} else {
RuleList->Last->Next = pObjRule;
RuleList->Last = pObjRule;
}
} else {
pObjRule->WildCard = FALSE;
// Insert rule at the begining
if (RuleList->First == NULL) {
RuleList->First = RuleList->Last = pObjRule;
pObjRule->Next = NULL;
} else {
pObjRule->Next = RuleList->First;
RuleList->First = pObjRule;
}
}
}
}
//*****************************************************************************
// LoadRule
//
// Caches all rules for a given registry value (REG_MULTI_SZ).
//
// Parameters:
// RuleList The rule list.
// hKey The registry key.
// ValueName The name of theregistry value.
// SystemGlobalRule If true, the object is to be SYSTEM_GLOBAL.
// Return Value:
// None.
//*****************************************************************************
void LoadRule (POBJRULELIST RuleList, HKEY hKey,
PWSTR ValueName, BOOL SystemGlobalRule)
{
PKEY_VALUE_PARTIAL_INFORMATION ValueInfo = NULL;
PWSTR Token;
PWSTR EndData;
if (!GetMultiSzValue(hKey,ValueName,&ValueInfo)) {
return;
}
EndData = (PWSTR) (ValueInfo->Data + ValueInfo->DataLength);
for (Token = (PWSTR)ValueInfo->Data;
(*Token && (Token < EndData));
Token++) {
AddRule(RuleList, Token, SystemGlobalRule);
while (*Token) {
Token++;
}
}
RtlFreeHeap(RtlProcessHeap(), 0, ValueInfo);
}
//*****************************************************************************
// LoadRules
//
// Caches all rules for in an OBJECTRULES directory.
// (e.g. Citrix\Compatibility\Applications\<APPNAME>\ObjectRules).
//
// Parameters:
// hKey The registry key of the ObjectRules directory.
// Return Value:
// None.
//*****************************************************************************
void LoadRules (HANDLE hKey)
{
ULONG i;
PRULEINITENTRY pTab;
for (i=0, pTab=RuleInitTab;i<NumRuleLists;i++,pTab++) {
LoadRule(pTab->ObjRuleList, hKey, pTab->UserGlobalValue, FALSE);
LoadRule(pTab->ObjRuleList, hKey, pTab->SystemGlobalValue, TRUE);
}
}
#define BuildObjRulePath(BasePath,ModName) \
{ \
wcscpy(KeyName,BasePath ); \
wcscat(KeyName,ModName); \
wcscat(KeyName,L"\\"); \
wcscat(KeyName,TERMSRV_COMPAT_OBJRULES); \
RtlInitUnicodeString(&UniString, KeyName); \
InitializeObjectAttributes(&ObjectAttributes, \
&UniString, \
OBJ_CASE_INSENSITIVE, \
NULL, \
NULL); \
}
//*****************************************************************************
// CtxInitObjRuleCache
//
// Loads all object rules for a given application. Called at DLL process
// attach time.
// Rules are in Citrix\Compatibility\Applications\<APPNAME>\ObjectRules
// Also loads all rules for DLLs listed in:
// Citrix\Compatibility\Applications\<APPNAME>\ObjectRules\Dlls
// Parameters:
// None.
// Return Value:
// None.
//*****************************************************************************
void CtxInitObjRuleCache(void)
{
WCHAR ModName[MAX_PATH+1];
WCHAR KeyName[sizeof(TERMSRV_COMPAT_APP)/sizeof(WCHAR)+
sizeof(TERMSRV_COMPAT_OBJRULES)/sizeof(WCHAR)+MAX_PATH+2];
UNICODE_STRING UniString;
PWSTR DllName;
PWSTR EndData;
OBJECT_ATTRIBUTES ObjectAttributes;
PKEY_VALUE_PARTIAL_INFORMATION ValueInfo = NULL;
HKEY hKey = 0;
DWORD AppType;
ULONG i;
// Initialize list to empty
NumRuleLists = sizeof(RuleInitTab) / sizeof(RULEINITENTRY);
for (i=0; i<NumRuleLists ;i++ ) {
InitRuleList(RuleInitTab[i].ObjRuleList);
}
// Get the module name
if (!GetAppTypeAndModName(&AppType,ModName, sizeof(ModName))) {
return;
}
// Determine of the ObjRules Key exists for this app
BuildObjRulePath(TERMSRV_COMPAT_APP,ModName)
if (!NT_SUCCESS(NtOpenKey(&hKey, KEY_READ, &ObjectAttributes))) {
return;
}
LoadRules(hKey);
if (!GetMultiSzValue(hKey,TERMSRV_COMPAT_DLLRULES,&ValueInfo)) {
CloseHandle(hKey);
return;
}
CloseHandle(hKey);
// Load the DLL Rules
EndData = (PWSTR) (ValueInfo->Data + ValueInfo->DataLength);
for(DllName = (PWSTR) ValueInfo->Data;
(*DllName && (DllName < EndData));
DllName++) {
BuildObjRulePath(TERMSRV_COMPAT_DLLS, DllName)
if (NT_SUCCESS(NtOpenKey(&hKey, KEY_READ, &ObjectAttributes))) {
LoadRules(hKey);
CloseHandle(hKey);
}
while (*DllName) {
DllName++;
}
}
RtlFreeHeap(RtlProcessHeap(), 0, ValueInfo);
}
//*****************************************************************************
// CtxLookupObjectRule
//
// Searches for an object rule for the named object. If a rule is found,
// the object attributes are modifed to reflect the desired setting of
// USER_GLOBAL or SYSTEM_GLOBAL. If no rule is found, the object
// atributes are unmodified.
//
// Parameters:
// RuleList The rule list to search (based on object type)
// ObjName The name of the object.
// ObjAttributes The object attribute structure.
// None.
// Return Value:
// None.
//*****************************************************************************
void CtxLookupObjectRule(POBJRULELIST RuleList, LPCWSTR ObjName, LPWSTR ObjNameExt)
{
POBJRULE ObjRule;
#define ApplyRule \
{ \
if (ObjRule->SystemGlobal) { \
wcscpy(ObjNameExt,L"Global\\"); \
} else { \
wcscpy(ObjNameExt,L"Local\\"); \
} \
}
for (ObjRule = RuleList->First; ObjRule; ObjRule = ObjRule->Next) {
if (!ObjRule->WildCard) {
if (!_wcsicmp(ObjName, ObjRule->ObjName)) {
#if DBG
DbgPrint("Object rule found for %ws System Global: %d\n",
ObjName, ObjRule->SystemGlobal);
#endif
ApplyRule
return;
}
} else {
if (!_wcsnicmp(ObjName, ObjRule->ObjName, ObjRule->MatchLen)) {
#if DBG
DbgPrint("Object rule found for %ws System Global: %d\n",
ObjName, ObjRule->SystemGlobal);
#endif
ApplyRule
return;
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink