windows-nt/Source/XPSP1/NT/shell/shlwapi/gcount.cpp
2020-09-26 16:20:57 +08:00

330 lines
9.2 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;
}