330 lines
9.5 KiB
C++
330 lines
9.5 KiB
C++
//
|
|
// Global counters
|
|
//
|
|
//
|
|
|
|
#include "priv.h"
|
|
|
|
//
|
|
// #defines
|
|
//
|
|
#ifdef DEBUG
|
|
#define GLOBAL_COUNTER_WAIT_TIMEOUT 30*1000 // on debug we set this to 30 seconds
|
|
#else
|
|
#define GLOBAL_COUNTER_WAIT_TIMEOUT 0 // on retail its zero so we test the objects state and return immedaeately
|
|
#endif
|
|
|
|
//
|
|
// Globals
|
|
//
|
|
SECURITY_ATTRIBUTES g_sa;
|
|
SECURITY_DESCRIPTOR* g_psd = NULL;
|
|
|
|
|
|
|
|
//
|
|
// this function allocates the g_psd and fills in the g_sa
|
|
//
|
|
STDAPI_(BOOL) AllocGlobalSecurityAttributes()
|
|
{
|
|
BOOL bRet;
|
|
SHELL_USER_PERMISSION supEveryone;
|
|
SHELL_USER_PERMISSION supSystem;
|
|
SHELL_USER_PERMISSION supAdministrators;
|
|
PSHELL_USER_PERMISSION apUserPerm[3] = {&supEveryone, &supAdministrators, &supSystem};
|
|
|
|
//
|
|
// There are three kinds of null-type DACLs.
|
|
//
|
|
// 1. No DACL. This means that we inherit the ambient DACL
|
|
// from our thread.
|
|
// 2. Null DACL. This means "full access to everyone".
|
|
// 3. Empty DACL. This means "deny all access to everyone".
|
|
//
|
|
// NONE of these are correct for our needs. We used to use Null DACL's (2),
|
|
// but the issue with these is that someone can change the ACL on the object
|
|
// locking us out.
|
|
//
|
|
// So now we create a specific DACL with 3 ACE's in it:
|
|
//
|
|
// ACE #1: Everyone - GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | SYNCHRONIZE
|
|
// ACE #2: SYSTEM - GENERIC_ALL (full control)
|
|
// ACE #3: Administrators - GENERIC_ALL (full control)
|
|
//
|
|
|
|
// we want the everyone to have read, write, exec and sync only
|
|
supEveryone.susID = susEveryone;
|
|
supEveryone.dwAccessType = ACCESS_ALLOWED_ACE_TYPE;
|
|
supEveryone.dwAccessMask = (GENERIC_READ | GENERIC_WRITE | GENERIC_EXECUTE | SYNCHRONIZE);
|
|
supEveryone.fInherit = FALSE;
|
|
supEveryone.dwInheritMask = 0;
|
|
supEveryone.dwInheritAccessMask = 0;
|
|
|
|
// we want the SYSTEM to have full control
|
|
supSystem.susID = susSystem;
|
|
supSystem.dwAccessType = ACCESS_ALLOWED_ACE_TYPE;
|
|
supSystem.dwAccessMask = GENERIC_ALL;
|
|
supSystem.fInherit = FALSE;
|
|
supSystem.dwInheritMask = 0;
|
|
supSystem.dwInheritAccessMask = 0;
|
|
|
|
// we want the Administrators to have full control
|
|
supAdministrators.susID = susAdministrators;
|
|
supAdministrators.dwAccessType = ACCESS_ALLOWED_ACE_TYPE;
|
|
supAdministrators.dwAccessMask = GENERIC_ALL;
|
|
supAdministrators.fInherit = FALSE;
|
|
supAdministrators.dwInheritMask = 0;
|
|
supAdministrators.dwInheritAccessMask = 0;
|
|
|
|
// allocate the global SECURITY_DESCRIPTOR
|
|
g_psd = GetShellSecurityDescriptor(apUserPerm, ARRAYSIZE(apUserPerm));
|
|
|
|
if (!g_psd)
|
|
{
|
|
TraceMsg(TF_WARNING, "InitGlobalSecurityAttributes: failed to create g_psd!");
|
|
bRet = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// we successfully alloced the g_psd, so set it into the g_sa
|
|
// NOTE: we will free g_psd at process detach
|
|
g_sa.nLength = sizeof(g_sa);
|
|
g_sa.lpSecurityDescriptor = g_psd;
|
|
g_sa.bInheritHandle = FALSE;
|
|
|
|
bRet = TRUE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
//
|
|
// called at process detach to release our global g_psd
|
|
//
|
|
STDAPI_(void) FreeGlobalSecurityAttributes()
|
|
{
|
|
if (g_psd)
|
|
{
|
|
ASSERT(g_sa.lpSecurityDescriptor == g_psd); // sanity check
|
|
LocalFree(g_psd);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// Helper function that clones an ACL
|
|
//
|
|
PACL CloneACL(const ACL* pAclSource)
|
|
{
|
|
PACL pAclClone = (PACL)LocalAlloc(LPTR, pAclSource->AclSize);
|
|
|
|
if (pAclClone)
|
|
{
|
|
CopyMemory((void*)pAclClone, (const void*)pAclSource, pAclSource->AclSize);
|
|
}
|
|
|
|
return pAclClone;
|
|
}
|
|
|
|
|
|
//
|
|
// This function fills in a SECURITY_ATTRIBUTES struct such that it will be full access to everyone.
|
|
// This is needed when multiple processes need access to the same named kernel objects.
|
|
//
|
|
// You should always pass (NULL, NULL, NULL) to this function for perf! (will return global security object)
|
|
//
|
|
// NOTE: for older callers who pass a non-null ppacl, must LocalFree it
|
|
//
|
|
STDAPI_(SECURITY_ATTRIBUTES*) CreateAllAccessSecurityAttributes(SECURITY_ATTRIBUTES* psa, SECURITY_DESCRIPTOR* psd, PACL* ppacl)
|
|
{
|
|
static BOOL s_bCreatedGlobalSA = FALSE;
|
|
|
|
// Win9x doesn't use dacls
|
|
if (!g_bRunningOnNT)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
// only rip on whistler or greater since the old ie55/ie6 code was lame
|
|
if (IsOS(OS_WHISTLERORGREATER))
|
|
{
|
|
// NOTE: (reinerf) - no shell caller should ever pass anything but NULL's to this api!
|
|
RIPMSG(!(psa || psd || ppacl), "CreateAllAccessSecurityAttributes: ALL callers should pass (NULL, NULL, NULL) for params!");
|
|
}
|
|
#endif
|
|
|
|
// always set this to null, we return a refrence to g_psd which
|
|
// contains the ACL and we never want the user to free anything
|
|
if (ppacl)
|
|
{
|
|
*ppacl = NULL;
|
|
}
|
|
|
|
if (!s_bCreatedGlobalSA)
|
|
{
|
|
// we have not inited g_sa, so do so now.
|
|
ENTERCRITICAL;
|
|
// check again within the critsec
|
|
if (!s_bCreatedGlobalSA)
|
|
{
|
|
if (AllocGlobalSecurityAttributes())
|
|
{
|
|
s_bCreatedGlobalSA = TRUE;
|
|
}
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
if (!s_bCreatedGlobalSA)
|
|
{
|
|
// failed to create the global! doh!
|
|
return NULL;
|
|
}
|
|
|
|
// if we got this far, this had better be created
|
|
ASSERT(g_psd);
|
|
}
|
|
|
|
// check to see if an older caller passed in non-null params
|
|
if (psa)
|
|
{
|
|
PACL pAcl = CloneACL(g_psd->Dacl);
|
|
|
|
if (pAcl &&
|
|
InitializeSecurityDescriptor(psd, SECURITY_DESCRIPTOR_REVISION) &&
|
|
SetSecurityDescriptorDacl(psd, TRUE, pAcl, FALSE))
|
|
{
|
|
psa->nLength = sizeof(*psa);
|
|
psa->lpSecurityDescriptor = psd;
|
|
psa->bInheritHandle = FALSE;
|
|
|
|
if (ppacl)
|
|
{
|
|
*ppacl = pAcl;
|
|
}
|
|
|
|
// NOTE: (reinerf) - we used to call LocalFree(pAcl) if the caller passed null for ppacl.
|
|
// This is a bad thing to do since SetSecurityDescriptor sets a refrence to the ACL instead
|
|
// of copying it. Better to leak it... :-(
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return psa;
|
|
}
|
|
else
|
|
{
|
|
|
|
// for newer callers (who pass all NULL's), we just return a refrence to our global
|
|
return &g_sa;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// This lets the user pass an ANSI String as the name of the global counter, as well as an inital value
|
|
//
|
|
STDAPI_(HANDLE) SHGlobalCounterCreateNamedA(LPCSTR szName, LONG lInitialValue)
|
|
{
|
|
HANDLE hSem;
|
|
//
|
|
// Explicitly ANSI so it runs on Win95.
|
|
//
|
|
char szCounterName[MAX_PATH]; // "shell.szName"
|
|
LPSECURITY_ATTRIBUTES psa;
|
|
|
|
lstrcpyA(szCounterName, "shell.");
|
|
StrCatBuffA(szCounterName, szName, ARRAYSIZE(szCounterName));
|
|
|
|
psa = CreateAllAccessSecurityAttributes(NULL, NULL, NULL);
|
|
hSem = CreateSemaphoreA(psa, lInitialValue, 0x7FFFFFFF, szCounterName);
|
|
if (!hSem)
|
|
hSem = OpenSemaphoreA(SEMAPHORE_MODIFY_STATE | SYNCHRONIZE, FALSE, szCounterName);
|
|
|
|
return hSem;
|
|
}
|
|
|
|
|
|
//
|
|
// This lets the user pass an UNICODE String as the name of the global counter, as well as an inital value
|
|
//
|
|
STDAPI_(HANDLE) SHGlobalCounterCreateNamedW(LPCWSTR szName, LONG lInitialValue)
|
|
{
|
|
CHAR szCounterName[MAX_PATH];
|
|
|
|
SHUnicodeToAnsi(szName, szCounterName, ARRAYSIZE(szCounterName));
|
|
|
|
return SHGlobalCounterCreateNamedA(szCounterName, lInitialValue);
|
|
}
|
|
|
|
|
|
//
|
|
// This lets the user pass a GUID. The name of the global counter will be "shell.{guid}",
|
|
// and its initial value will be zero.
|
|
//
|
|
STDAPI_(HANDLE) SHGlobalCounterCreate(REFGUID rguid)
|
|
{
|
|
CHAR szGUIDString[GUIDSTR_MAX];
|
|
|
|
SHStringFromGUIDA(rguid, szGUIDString, ARRAYSIZE(szGUIDString));
|
|
|
|
return SHGlobalCounterCreateNamedA(szGUIDString, 0);
|
|
}
|
|
|
|
|
|
// returns current value of the global counter
|
|
// Note: The result is not thread-safe in the sense that if two threads
|
|
// look at the value at the same time, one of them might read the wrong
|
|
// value.
|
|
STDAPI_(long) SHGlobalCounterGetValue(HANDLE hCounter)
|
|
{
|
|
long lPreviousValue = 0;
|
|
DWORD dwRet;
|
|
|
|
ReleaseSemaphore(hCounter, 1, &lPreviousValue); // poll and bump the count
|
|
dwRet = WaitForSingleObject(hCounter, GLOBAL_COUNTER_WAIT_TIMEOUT); // reduce the count
|
|
|
|
// this shouldnt happen since we just bumped up the count above
|
|
ASSERT(dwRet != WAIT_TIMEOUT);
|
|
|
|
return lPreviousValue;
|
|
}
|
|
|
|
|
|
// returns new value
|
|
// Note: this _is_ thread safe
|
|
STDAPI_(long) SHGlobalCounterIncrement(HANDLE hCounter)
|
|
{
|
|
long lPreviousValue = 0;
|
|
|
|
ReleaseSemaphore(hCounter, 1, &lPreviousValue); // bump the count
|
|
return lPreviousValue + 1;
|
|
}
|
|
|
|
// returns new value
|
|
// Note: The result is not thread-safe in the sense that if two threads
|
|
// try to decrement the value at the same time, whacky stuff can happen.
|
|
STDAPI_(long) SHGlobalCounterDecrement(HANDLE hCounter)
|
|
{
|
|
DWORD dwRet;
|
|
long lCurrentValue = SHGlobalCounterGetValue(hCounter);
|
|
|
|
#ifdef DEBUG
|
|
// extra sanity check
|
|
if (lCurrentValue == 0)
|
|
{
|
|
ASSERTMSG(FALSE, "SHGlobalCounterDecrement called on a counter that was already equal to 0 !!");
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
dwRet = WaitForSingleObject(hCounter, GLOBAL_COUNTER_WAIT_TIMEOUT); // reduce the count
|
|
|
|
ASSERT(dwRet != WAIT_TIMEOUT);
|
|
|
|
return lCurrentValue - 1;
|
|
}
|