archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/shell/shell32/scnotify.cpp

3105 lines
92 KiB
Raw Blame History

#include "shellprv.h"
#pragma hdrstop
#include <initguid.h>
#include <dbt.h>
#include "printer.h"
#include <dpa.h>
#include "idltree.h"
#include "scnotifyp.h"
#include "mtpt.h"
#include "shitemid.h"
#include <ioevent.h>
#define TF_SHELLCHANGENOTIFY 0x40000
#define SCNM_REGISTERCLIENT WM_USER + 1
#define SCNM_DEREGISTERCLIENT WM_USER + 2
#define SCNM_NOTIFYEVENT WM_USER + 3
#define SCNM_FLUSHEVENTS WM_USER + 4
#define SCNM_TERMINATE WM_USER + 5
#define SCNM_SUSPENDRESUME WM_USER + 6
#define SCNM_DEREGISTERWINDOW WM_USER + 7
#define SCNM_AUTOPLAYDRIVE WM_USER + 8
enum
{
FLUSH_OVERFLOW = 1,
FLUSH_SOFT,
FLUSH_HARD,
FLUSH_INTERRUPT,
};
#define IDT_SCN_FLUSHEVENTS 1
#define IDT_SCN_FRESHENTREES 2
#define EVENT_OVERFLOW 10
HWND g_hwndSCN = NULL;
CChangeNotify *g_pscn = NULL;
EXTERN_C CRITICAL_SECTION g_csSCN;
CRITICAL_SECTION g_csSCN = {0};
#define PERFTEST(x)
EXTERN_C void SFP_FSEvent (LONG lEvent, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra);
EXTERN_C int WINAPI RLFSChanged (LONG lEvent, LPITEMIDLIST pidl, LPITEMIDLIST pidlExtra);
STDAPI CFSFolder_IconEvent(LONG lEvent, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra);
STDAPI_(HWND) _SCNGetWindow(BOOL fUseDesktop, BOOL fNeedsFallback);
STDAPI SHChangeNotifyAutoplayDrive(PCWSTR pszDrive)
{
ASSERT(PathIsRoot(pszDrive));
HWND hwnd = _SCNGetWindow(TRUE, FALSE);
if (hwnd)
{
DWORD dwProcessID = 0;
GetWindowThreadProcessId(hwnd, &dwProcessID);
if (dwProcessID)
{
AllowSetForegroundWindow(dwProcessID);
}
PostMessage(g_hwndSCN, SCNM_AUTOPLAYDRIVE, DRIVEID(pszDrive), 0);
return S_OK;
}
return E_FAIL;
}
//
// special folders that are aliases. these are always running
// csidlAlias refers to the users perceived namespace
// csidlReal refers to the actual filesystem folder behind the alias
//
typedef struct ALIASFOLDER {
int csidlAlias;
int csidlReal;
} ALIASFOLDER, *PALIASFOLDER;
static const ALIASFOLDER s_rgaf[] = {
{CSIDL_DESKTOP, CSIDL_DESKTOPDIRECTORY},
{CSIDL_DESKTOP, CSIDL_COMMON_DESKTOPDIRECTORY },
{CSIDL_PERSONAL, CSIDL_PERSONAL | CSIDL_FLAG_NO_ALIAS},
{CSIDL_NETWORK, CSIDL_NETHOOD},
{CSIDL_PRINTERS, CSIDL_PRINTHOOD},
};
void InitAliasFolderTable(void)
{
for (int i = 0; i < ARRAYSIZE(s_rgaf); i++)
{
g_pscn->AddSpecialAlias(s_rgaf[i].csidlReal, s_rgaf[i].csidlAlias);
}
}
#pragma pack(1)
typedef struct {
WORD cb;
LONG lEEvent;
} ALIASREGISTER;
typedef struct {
ALIASREGISTER ar;
WORD wNull;
} ALIASREGISTERLIST;
#pragma pack()
STDAPI_(void) SHChangeNotifyRegisterAlias(LPCITEMIDLIST pidlReal, LPCITEMIDLIST pidlAlias)
{
static const ALIASREGISTERLIST arl = { {sizeof(ALIASREGISTER), SHCNEE_ALIASINUSE}, 0};
LPITEMIDLIST pidlRegister = ILCombine((LPCITEMIDLIST)&arl, pidlReal);
if (pidlRegister)
{
SHChangeNotify(SHCNE_EXTENDED_EVENT, SHCNF_ONLYNOTIFYINTERNALS | SHCNF_IDLIST, pidlRegister, pidlAlias);
ILFree(pidlRegister);
}
}
LPCITEMIDLIST IsAliasRegisterPidl(LPCITEMIDLIST pidl)
{
ALIASREGISTER *par = (ALIASREGISTER *)pidl;
if (par->cb == sizeof(ALIASREGISTER)
&& par->lEEvent == SHCNEE_ALIASINUSE)
return _ILNext(pidl);
return NULL;
}
LONG g_cAliases = 0;
LPITEMIDLIST TranslateAlias(LPCITEMIDLIST pidl, LPCITEMIDLIST pidlReal, LPCITEMIDLIST pidlAlias)
{
// see if its child of one of our watched items
LPCITEMIDLIST pidlChild = pidl ? ILFindChild(pidlReal, pidl) : NULL;
if (pidlChild)
{
return ILCombine(pidlAlias, pidlChild);
}
return NULL;
}
CAnyAlias::~CAnyAlias()
{
ILFree(_pidlAlias);
ATOMICRELEASE(_ptscn);
}
BOOL CCollapsingClient::Init(LPCITEMIDLIST pidl, BOOL fRecursive)
{
_pidl = ILClone(pidl);
_fRecursive = fRecursive;
return (_pidl && _dpaPendingEvents.Create(EVENT_OVERFLOW + 1));
}
BOOL CAnyAlias::Init(LPCITEMIDLIST pidlReal, LPCITEMIDLIST pidlAlias)
{
ASSERT(!_fSpecial);
_pidlAlias = ILClone(pidlAlias);
return (_pidlAlias && CCollapsingClient::Init(pidlReal, TRUE));
}
BOOL CAnyAlias::_WantsEvent(LONG lEvent)
{
return (lEvent & (SHCNE_DISKEVENTS | SHCNE_DRIVEREMOVED | SHCNE_NETSHARE | SHCNE_NETUNSHARE));
}
BOOL CAnyAlias::InitSpecial(int csidlReal, int csidlAlias)
{
_fSpecial = TRUE;
_csidlReal = csidlReal;
_csidlAlias = csidlAlias;
LPITEMIDLIST pidlNew;
WIN32_FIND_DATA fd = {0};
fd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY; // Special folders are always directories
SHGetSpecialFolderPath(NULL, fd.cFileName, csidlReal | CSIDL_FLAG_DONT_VERIFY, FALSE);
SHSimpleIDListFromFindData(fd.cFileName, &fd, &pidlNew);
SHGetSpecialFolderLocation(NULL, csidlAlias | CSIDL_FLAG_DONT_VERIFY, &_pidlAlias);
BOOL fRet = _pidlAlias && CCollapsingClient::Init(pidlNew, TRUE);
ILFree(pidlNew);
return fRet;
}
BOOL CAnyAlias::IsAlias(LPCITEMIDLIST pidlReal, LPCITEMIDLIST pidlAlias)
{
// if this hits, an alias has been registered already
// this means the guy doing the registration isn't doing it at the junction point like
// theyre supposed to
ASSERT((ILIsEqual(pidlReal, _pidl) && ILIsEqual(pidlAlias, _pidlAlias)) ||
!(ILIsParent(_pidl, pidlReal, FALSE) && ILIsParent(_pidlAlias, pidlAlias, FALSE)));
return (ILIsEqual(pidlReal, _pidl)
&& ILIsEqual(pidlAlias, _pidlAlias));
}
BOOL CAnyAlias::IsSpecial(int csidlReal, int csidlAlias)
{
return (_fSpecial && csidlReal == _csidlReal && csidlAlias == _csidlAlias);
}
CAnyAlias::_CustomTranslate()
{
if (!_fCheckedCustom)
{
SHBindToObjectEx(NULL, _pidlAlias, NULL, IID_PPV_ARG(ITranslateShellChangeNotify, &_ptscn));
_fCheckedCustom = TRUE;
}
return (_ptscn != NULL);
}
// some pidl translators may not translate the event. if we pass on a notifyevent thats identical,
// we'll get into an infinite loop. our translators are good about this so this doesnt happen, but
// we'll catch it here to be more robust -- we wouldnt want a bad translating shell extension to
// be able to spinlock the changenotify thread.
BOOL CAnyAlias::_OkayToNotifyTranslatedEvent(CNotifyEvent *pne, LONG lEvent, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra)
{
// mydocs has an issue where it can be removed from the desktop when
// it is redirected, because the alias only propagates the first
// half of the notification (remove). so we dont Translate the remove.
if (_fSpecial && _csidlAlias == CSIDL_PERSONAL)
{
if (pne->lEvent == SHCNE_RENAMEFOLDER || pne->lEvent == SHCNE_RMDIR)
{
if (ILIsEqual(pidl, _pidlAlias))
return FALSE;
}
}
// if the original event wasn't already translated, let it proceed.
// if its a different event, its fine -- a translator could flip-flop between events but we cant detect that case.
// in addition we need to beware of aliases that translate to themselves or their children --
// for example a my computer shortcut in the start menu will be registered recursively, so if you try
// to delete it it will get into a loop.
// so if the events are the same, verify that both the resultant pidls aren't underneath _pidl.
return !(pne->uEventFlags & SHCNF_TRANSLATEDALIAS) ||
(lEvent != pne->lEvent) ||
!(pidl && ILIsParent(_pidl, pidl, FALSE)) && !(pidlExtra && ILIsParent(_pidl, pidlExtra, FALSE));
}
void CAnyAlias::_SendNotification(CNotifyEvent *pne, BOOL fNeedsCallbackEvent, SENDASYNCPROC pfncb)
{
//
// see if its child of one of our watched items
if (_CustomTranslate())
{
LPITEMIDLIST pidl1Alias = pne->pidl;
LPITEMIDLIST pidl1AliasExtra = pne->pidlExtra;
LPITEMIDLIST pidl2Alias = NULL, pidl2AliasExtra = NULL;
LONG lEvent1 = pne->lEvent & ~SHCNE_INTERRUPT; // translator shouldn't see this flag
LONG lEvent2 = -1;
if (SUCCEEDED(_ptscn->TranslateIDs(&lEvent1, pne->pidl, pne->pidlExtra, &pidl1Alias, &pidl1AliasExtra,
&lEvent2, &pidl2Alias, &pidl2AliasExtra)))
{
if (_OkayToNotifyTranslatedEvent(pne, lEvent1, pidl1Alias, pidl1AliasExtra))
{
g_pscn->NotifyEvent(lEvent1, SHCNF_IDLIST | SHCNF_TRANSLATEDALIAS,
pidl1Alias, pidl1AliasExtra,
pne->dwEventTime);
}
if ((lEvent2 != -1) && _OkayToNotifyTranslatedEvent(pne, lEvent2, pidl2Alias, pidl2AliasExtra))
{
g_pscn->NotifyEvent(lEvent2, SHCNF_IDLIST | SHCNF_TRANSLATEDALIAS,
pidl2Alias, pidl2AliasExtra,
pne->dwEventTime);
}
if (pidl1Alias != pne->pidl)
ILFree(pidl1Alias);
if (pidl1AliasExtra != pne->pidlExtra)
ILFree(pidl1AliasExtra);
ILFree(pidl2Alias);
ILFree(pidl2AliasExtra);
}
}
else
{
LPITEMIDLIST pidlAlias = TranslateAlias(pne->pidl, _pidl, _pidlAlias);
LPITEMIDLIST pidlAliasExtra = TranslateAlias(pne->pidlExtra, _pidl, _pidlAlias);
if (pidlAlias || pidlAliasExtra)
{
LPCITEMIDLIST pidlNotify = pidlAlias ? pidlAlias : pne->pidl;
LPCITEMIDLIST pidlNotifyExtra = pidlAliasExtra ? pidlAliasExtra : pne->pidlExtra;
if (_OkayToNotifyTranslatedEvent(pne, pne->lEvent, pidlNotify, pidlNotifyExtra))
{
g_pscn->NotifyEvent(pne->lEvent, SHCNF_IDLIST | SHCNF_TRANSLATEDALIAS,
pidlNotify, pidlNotifyExtra,
pne->dwEventTime);
}
// do some special handling here
// like refresh folders or something will clean out an entry.
switch (pne->lEvent)
{
case SHCNE_UPDATEDIR:
if (!_fSpecial && ILIsEqual(pne->pidl, _pidl))
{
// this is target, and it will be refreshed.
// if the alias is still around, then it will
// have to reenum and re-register
// there-fore we will clean this out now.
_fRemove = TRUE;
}
break;
default:
break;
}
ILFree(pidlAlias);
ILFree(pidlAliasExtra);
}
}
// this is the notify we get when a drive mapping is deleted
// when this happens we need to kill the aliases to that drive
if (pne->lEvent == SHCNE_DRIVEREMOVED)
{
if (!_fSpecial && ILIsEqual(pne->pidl, _pidlAlias))
{
// when net drives are removed
// pidlExtra is the UNC
_fRemove = TRUE;
}
}
}
void CAnyAlias::Activate(BOOL fActivate)
{
if (fActivate)
{
ASSERT(_cActivated >= 0);
if (!_cActivated++)
{
// turn this puppy on!
_fRemove = FALSE;
if (!_fInterrupt)
_fInterrupt = g_pscn->AddInterruptSource(_pidl, TRUE);
}
}
else
{
ASSERT(_cActivated > 0);
if (!--_cActivated)
{
// now turn it off
_fRemove = TRUE;
g_pscn->SetFlush(FLUSH_SOFT);
}
}
}
void CChangeNotify::_CheckAliasRollover(void)
{
static DWORD s_tick = 0;
DWORD tick = GetTickCount();
if (tick < s_tick)
{
// we rolled the tick count over
CLinkedWalk<CAnyAlias> lw(&_listAliases);
while (lw.Step())
{
lw.That()->_dwTime = tick;
}
}
s_tick = tick;
}
CAnyAlias *CChangeNotify::_FindSpecialAlias(int csidlReal, int csidlAlias)
{
CLinkedWalk<CAnyAlias> lw(&_listAliases);
while (lw.Step())
{
CAnyAlias *paa = lw.That();
if (paa->IsSpecial(csidlReal, csidlAlias))
{
// we found it
return paa;
}
}
return NULL;
}
CAnyAlias *CChangeNotify::_FindAlias(LPCITEMIDLIST pidlReal, LPCITEMIDLIST pidlAlias)
{
CLinkedWalk<CAnyAlias> lw(&_listAliases);
while (lw.Step())
{
CAnyAlias *paa = lw.That();
if (paa->IsAlias(pidlReal, pidlAlias))
{
// we found it
return paa;
}
}
return NULL;
}
void CChangeNotify::AddSpecialAlias(int csidlReal, int csidlAlias)
{
CAnyAlias *paa = _FindSpecialAlias(csidlReal, csidlAlias);
if (!paa)
{
CLinkedNode<CAnyAlias> *p = new CLinkedNode<CAnyAlias>;
if (p)
{
if (p->that.InitSpecial(csidlReal, csidlAlias))
{
if (_InsertAlias(p))
paa = &p->that;
}
if (!paa)
delete p;
}
}
}
void CChangeNotify::UpdateSpecialAlias(int csidlAlias)
{
for (int i = 0; i < ARRAYSIZE(s_rgaf); i++)
{
if (csidlAlias == s_rgaf[i].csidlAlias)
{
CLinkedNode<CAnyAlias> *p = new CLinkedNode<CAnyAlias>;
if (p)
{
if (!p->that.InitSpecial(s_rgaf[i].csidlReal, csidlAlias)
|| !_InsertAlias(p))
{
delete p;
}
}
break;
}
}
}
// the semantic of the return value of this function is not necessarily success or failure,
// since it's possible to stick something in _ptreeAliases with AddData and not be able to
// clean up and remove it with RemoveData (if CompareIDs fails along the way).
// reordering our inserts won't help since g_pscn->AddClient does the same thing.
// so,
// return TRUE == do not free p, something has ownership
// return FALSE == free p, we dont reference it anywhere
BOOL CChangeNotify::_InsertAlias(CLinkedNode<CAnyAlias> *p)
{
BOOL fRet = _InitTree(&_ptreeAliases);
if (fRet)
{
fRet = _listAliases.Insert(p);
if (fRet)
{
fRet = SUCCEEDED(_ptreeAliases->AddData(IDLDATAF_MATCH_RECURSIVE, p->that._pidlAlias, (INT_PTR)&p->that));
if (fRet)
{
fRet = g_pscn->AddClient(IDLDATAF_MATCH_RECURSIVE, p->that._pidl, NULL, FALSE, SAFECAST(&p->that, CCollapsingClient *));
if (fRet)
{
if (_ptreeClients)
{
// now tell all the registered clients already waiting on this to wake up.
CLinkedWalk<CRegisteredClient> lw(&_listClients);
while (lw.Step())
{
if (ILIsParent(p->that._pidlAlias, lw.That()->_pidl, FALSE))
{
// increase activation count one time on this alias for each client that wants this one.
p->that.Activate(TRUE);
}
}
}
}
else
{
// if we blow it, then we need to clean up.
// right now both the tree and _listAliases have p.
_listAliases.Remove(p); // the list always succeeds
if (FAILED(_ptreeAliases->RemoveData(p->that._pidlAlias, (INT_PTR)&p->that)))
{
// oh no! we added it to the tree but we cant find it to remove it.
// return TRUE to prevent freeing it later.
fRet = TRUE;
}
}
}
else
{
// we only have to remove from _listAliases.
_listAliases.Remove(p); // the list always succeeds
}
}
}
return fRet;
}
void CChangeNotify::AddAlias(LPCITEMIDLIST pidlReal, LPCITEMIDLIST pidlAlias, DWORD dwEventTime)
{
CAnyAlias *paa = _FindAlias(pidlReal, pidlAlias);
if (!paa)
{
CLinkedNode<CAnyAlias> *p = new CLinkedNode<CAnyAlias>;
if (p)
{
if (p->that.Init(pidlReal, pidlAlias))
{
if (_InsertAlias(p))
{
paa = &p->that;
g_cAliases++;
}
}
if (!paa)
delete p;
}
}
if (paa)
{
// we just want to update the time on the existing entry
paa->_dwTime = dwEventTime;
paa->_fRemove = FALSE;
_CheckAliasRollover();
}
}
BOOL CAnyAlias::Remove()
{
if (_fRemove)
{
if (_fSpecial)
{
// we dont remove the special aliases,
// we only quiet them a little
if (_fInterrupt)
{
g_pscn->ReleaseInterruptSource(_pidl);
_fInterrupt = FALSE;
}
_fRemove = FALSE;
}
else
{
return SUCCEEDED(g_pscn->RemoveClient(_pidl, _fInterrupt, SAFECAST(this, CCollapsingClient *)));
}
}
return FALSE;
}
void CChangeNotify::_FreshenAliases(void)
{
CLinkedWalk<CAnyAlias> lw(&_listAliases);
while (lw.Step())
{
CAnyAlias *paa = lw.That();
if (paa->Remove())
{
if (SUCCEEDED(_ptreeAliases->RemoveData(paa->_pidlAlias, (INT_PTR)paa)))
{
// if RemoveData failed, we have to leak the client so the tree doesnt point to freed memory.
lw.Delete();
}
}
}
}
void AnyAlias_Change(LONG lEvent, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra, DWORD dwEventTime)
{
if (lEvent == SHCNE_EXTENDED_EVENT)
{
LPCITEMIDLIST pidlAlias = IsAliasRegisterPidl(pidl);
if (pidlAlias)
g_pscn->AddAlias(pidlAlias, pidlExtra, dwEventTime);
else
{
SHChangeDWORDAsIDList *pdwidl = (SHChangeDWORDAsIDList *)pidl;
if (pdwidl->dwItem1 == SHCNEE_UPDATEFOLDERLOCATION)
{
g_pscn->UpdateSpecialAlias(pdwidl->dwItem2);
}
}
}
}
void NotifyShellInternals(LONG lEvent, UINT uFlags, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra, DWORD dwEventTime)
{
// if they are only interested in the real deal
// make sure we dont pass them the translated events
// this keeps them from getting multiple notifications
// about the same paths, since the alias and the non-alias
// pidls will generally resolve to the same parsing name
// for the events/pidls that these guys are interested in
if (!(SHCNF_TRANSLATEDALIAS & uFlags))
{
PERFTEST(RLFS_EVENT) RLFSChanged(lEvent, (LPITEMIDLIST)pidl, (LPITEMIDLIST)pidlExtra);
PERFTEST(SFP_EVENT) SFP_FSEvent(lEvent, pidl, pidlExtra);
PERFTEST(ICON_EVENT) CFSFolder_IconEvent(lEvent, pidl, pidlExtra);
}
// aliases actually can be children of other aliases, so we need
// them to get the translated events
PERFTEST(ALIAS_EVENT) AnyAlias_Change(lEvent, pidl, pidlExtra, dwEventTime);
}
BOOL IsMultiBitSet(LONG l)
{
return (l && (l & (l-1)));
}
#define CHANGELOCK_SIG 0xbabebabe
#define CHANGEEVENT_SIG 0xfadefade
#define CHANGEREGISTER_SIG 0xdeafdeaf
#ifdef DEBUG
BOOL IsValidChangeEvent(CHANGEEVENT *pce)
{
return (pce && (pce->dwSig == CHANGEEVENT_SIG)
&& (!IsMultiBitSet(pce->lEvent)));
}
BOOL _LockSizeMatchEvent(CHANGELOCK *pcl)
{
UINT cbPidlMainAligned = (ILGetSize(pcl->pidlMain) + 3) & ~(0x0000003); // Round up to dword size
UINT cbPidlExtra = ILGetSize(pcl->pidlExtra);
DWORD cbSize = sizeof(CHANGEEVENT) + cbPidlMainAligned + cbPidlExtra;
return cbSize == pcl->pce->cbSize;
}
BOOL IsValidChangeLock(CHANGELOCK *pcl)
{
return (pcl && IsValidChangeEvent(pcl->pce)
&& (pcl->dwSig == CHANGELOCK_SIG)
&& _LockSizeMatchEvent(pcl));
}
BOOL IsValidChangeEventHandle(HANDLE h, DWORD id)
{
CHANGEEVENT *pce = (CHANGEEVENT *)SHLockSharedEx(h, id, FALSE);
#ifdef DEBUG
BOOL fRet = TRUE; // can fail in low memory so must default to TRUE
#endif // force DEBUG
if (pce)
{
fRet = IsValidChangeEvent(pce);
SHUnlockShared(pce);
}
return fRet;
}
#define ISVALIDCHANGEEVENTHANDLE(h, id) IsValidChangeEventHandle(h, id)
#define ISVALIDCHANGEEVENT(p) IsValidChangeEvent(p)
#define ISVALIDCHANGELOCK(p) IsValidChangeLock(p)
#define ISVALIDCHANGEREGISTER(p) TRUE
#endif
ULONG SHChangeNotification_Destroy(HANDLE hChange, DWORD dwProcId)
{
ASSERT(ISVALIDCHANGEEVENTHANDLE(hChange, dwProcId));
TraceMsg(TF_SHELLCHANGENOTIFY, "CHANGEEVENT destroyed [0x%X]", hChange);
return SHFreeShared(hChange, dwProcId);
}
HANDLE SHChangeNotification_Create(LONG lEvent, UINT uFlags, LPCITEMIDLIST pidlMain, LPCITEMIDLIST pidlExtra, DWORD dwProcId, DWORD dwEventTime)
{
// some bad callers send us multiple events
RIP(!IsMultiBitSet(lEvent));
if (!IsMultiBitSet(lEvent))
{
UINT cbPidlMain = ILGetSize(pidlMain);
UINT cbPidlMainAligned = (cbPidlMain + 3) & ~(0x0000003); // Round up to dword size
UINT cbPidlExtra = ILGetSize(pidlExtra);
DWORD cbSize = sizeof(CHANGEEVENT) + cbPidlMainAligned + cbPidlExtra;
HANDLE h = SHAllocShared(NULL, cbSize, dwProcId);
if (h)
{
CHANGEEVENT * pce = (CHANGEEVENT *) SHLockSharedEx(h, dwProcId, TRUE);
if (pce)
{
BYTE *lpb = (LPBYTE)(pce + 1);
pce->cbSize = cbSize;
pce->dwSig = CHANGEEVENT_SIG;
pce->lEvent = lEvent;
pce->uFlags = uFlags;
pce->dwEventTime = dwEventTime;
if (pidlMain)
{
pce->uidlMain = sizeof(CHANGEEVENT);
CopyMemory(lpb, pidlMain, cbPidlMain);
lpb += cbPidlMainAligned;
}
if (pidlExtra)
{
pce->uidlExtra = (UINT) (lpb - (LPBYTE)pce);
CopyMemory(lpb, pidlExtra, cbPidlExtra);
}
SHUnlockShared(pce);
TraceMsg(TF_SHELLCHANGENOTIFY, "CHANGEEVENT created [0x%X]", h);
}
else
{
SHFreeShared(h, dwProcId);
h = NULL;
}
}
return h;
}
return NULL;
}
CHANGELOCK *_SHChangeNotification_Lock(HANDLE hChange, DWORD dwProcId)
{
CHANGEEVENT *pce = (CHANGEEVENT *) SHLockSharedEx(hChange, dwProcId, FALSE);
if (pce)
{
#ifdef DEBUG
if (!ISVALIDCHANGEEVENT(pce))
{
// during shell32 development it is convenient to use .local to use
// a different version of shell32 than the os version. but then
// non-explorer processes use the old shell32 which might have
// a different CHANGEEVENT structure causing this assert to fire
// and us to fault shortly after. do this hack check to see if
// we are in this situation...
//
static int nExplorerIsLocalized = -1;
if (nExplorerIsLocalized < 1)
{
TCHAR szPath[MAX_PATH];
if (GetModuleFileName(HINST_THISDLL, szPath, ARRAYSIZE(szPath)))
{
PathRemoveFileSpec(szPath);
PathCombine(szPath, szPath, TEXT("explorer.exe.local"));
if (PathFileExists(szPath))
nExplorerIsLocalized = 1;
else
nExplorerIsLocalized = 0;
}
}
if (0==nExplorerIsLocalized)
{
// We should never send ourselves an invalid changeevent!
ASSERT(ISVALIDCHANGEEVENT(pce));
}
else
{
// Except in this case. Rip this out once hit -- I haven't been
// able to repro this in a while...
ASSERTMSG(ISVALIDCHANGEEVENT(pce), "Press 'g', if this doesn't fault you've validated a known .local bug fix for debug only that's hard to repro but a pain when it does. Remove this assert. Thanks.");
return NULL;
}
}
#endif
CHANGELOCK *pcl = (CHANGELOCK *)LocalAlloc(LPTR, sizeof(CHANGELOCK));
if (pcl)
{
pcl->dwSig = CHANGELOCK_SIG;
pcl->pce = pce;
if (pce->uidlMain)
pcl->pidlMain = _ILSkip(pce, pce->uidlMain);
if (pce->uidlExtra)
pcl->pidlExtra = _ILSkip(pce, pce->uidlExtra);
return pcl;
}
else
SHUnlockShared(pce);
}
return NULL;
}
HANDLE SHChangeNotification_Lock(HANDLE hChange, DWORD dwProcId, LPITEMIDLIST **pppidl, LONG *plEvent)
{
CHANGELOCK *pcl = _SHChangeNotification_Lock(hChange, dwProcId);
if (pcl)
{
//
// Give back some easy values (causes less code to change for now)
//
if (pppidl)
*pppidl = &(pcl->pidlMain);
if (plEvent)
*plEvent = pcl->pce->lEvent;
}
return (HANDLE) pcl;
}
BOOL SHChangeNotification_Unlock(HANDLE hLock)
{
CHANGELOCK *pcl = (CHANGELOCK *)hLock;
ASSERT(ISVALIDCHANGELOCK(pcl));
BOOL fRet = SHUnlockShared(pcl->pce);
LocalFree(pcl);
ASSERT(fRet);
return fRet;
}
STDMETHODIMP_(ULONG) CNotifyEvent::AddRef()
{
return InterlockedIncrement(&_cRef);
}
STDMETHODIMP_(ULONG) CNotifyEvent::Release()
{
ASSERT( 0 != _cRef );
ULONG cRef = InterlockedDecrement(&_cRef);
if ( 0 == cRef )
{
delete this;
}
return cRef;
}
BOOL CNotifyEvent::Init(LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra)
{
if (pidl)
this->pidl = ILClone(pidl);
if (pidlExtra)
this->pidlExtra = ILClone(pidlExtra);
return ((!pidl || this->pidl) && (!pidlExtra || this->pidlExtra));
}
CNotifyEvent *CNotifyEvent::Create(LONG lEvent, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra, DWORD dwEventTime, UINT uEventFlags)
{
CNotifyEvent *p = new CNotifyEvent(lEvent, dwEventTime, uEventFlags);
if (p)
{
if (!p->Init(pidl, pidlExtra))
{
// we failed here
p->Release();
p = NULL;
}
}
return p;
}
CCollapsingClient::CCollapsingClient()
{
}
CCollapsingClient::~CCollapsingClient()
{
ILFree(_pidl);
if (_dpaPendingEvents)
{
int iCount = _dpaPendingEvents.GetPtrCount();
while (iCount--)
{
CNotifyEvent *pne = _dpaPendingEvents.FastGetPtr(iCount);
// to parallel our UsingEvent() call
pne->Release();
}
_dpaPendingEvents.Destroy();
}
}
ULONG g_ulNextID = 1;
CRegisteredClient::CRegisteredClient()
{
//
// Skip ID 0, as this is our error value.
//
_ulID = g_ulNextID;
if (!++g_ulNextID)
g_ulNextID = 1;
}
CRegisteredClient::~CRegisteredClient()
{
TraceMsg(TF_SHELLCHANGENOTIFY, "SCN::~CRegisteredClient() [0x%X] id = %d", this, _ulID);
}
BOOL CRegisteredClient::Init(HWND hwnd, int fSources, LONG fEvents, UINT wMsg, SHChangeNotifyEntry *pfsne)
{
// need one or the other
ASSERT(fSources & (SHCNRF_InterruptLevel | SHCNRF_ShellLevel));
_hwnd = hwnd;
GetWindowThreadProcessId(hwnd, &_dwProcId);
_fSources = fSources;
_fInterrupt = fSources & SHCNRF_InterruptLevel;
_fEvents = fEvents;
_wMsg = wMsg;
LPITEMIDLIST pidlNew;
if (pfsne->pidl)
pidlNew = ILClone(pfsne->pidl);
else
pidlNew = SHCloneSpecialIDList(NULL, CSIDL_DESKTOP, FALSE);
BOOL fRet = CCollapsingClient::Init(pidlNew, pfsne->fRecursive);
ILFree(pidlNew);
return fRet;
}
BOOL CRegisteredClient::_WantsEvent(LONG lEvent)
{
if (!_fDeadClient && (lEvent & _fEvents))
{
//
// if this event was generated by an interrupt, and the
// client has interrupt notification turned off, we dont want it
//
if (lEvent & SHCNE_INTERRUPT)
{
if (!(_fSources & SHCNRF_InterruptLevel))
{
return FALSE;
}
}
else if (!(_fSources & SHCNRF_ShellLevel))
{
//
// This event was generated by the shell, and the
// client has shell notification turned off, so
// we skip it.
//
return FALSE;
}
return TRUE;
}
return FALSE;
}
BOOL CCollapsingClient::_CanCollapse(LONG lEvent)
{
return (!_CheckUpdatingSelf()
&& (lEvent & SHCNE_DISKEVENTS)
&& !(lEvent & SHCNE_GLOBALEVENTS)
&& (_dpaPendingEvents.GetPtrCount() >= EVENT_OVERFLOW));
}
STDAPI_(BOOL) ILIsEqualEx(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, BOOL fMatchDepth, LPARAM lParam);
//
// checks for null so we dont assert in ILIsEqual
//
BOOL ILIsEqualOrBothNull(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, BOOL fMemCmpOnly)
{
if (!pidl1 || !pidl2)
{
return (pidl1 == pidl2);
}
if (!fMemCmpOnly)
return ILIsEqualEx(pidl1, pidl2, TRUE, SHCIDS_CANONICALONLY);
else
{
UINT cb1 = ILGetSize(pidl1);
return (cb1 == ILGetSize(pidl2) && 0 == memcmp(pidl1, pidl2, cb1));
}
}
#define SHCNE_ELIMINATE_DUPE_EVENTS (SHCNE_ATTRIBUTES | SHCNE_UPDATEDIR | SHCNE_UPDATEITEM | SHCNE_UPDATEIMAGE | SHCNE_FREESPACE)
BOOL CCollapsingClient::_IsDupe(CNotifyEvent *pne)
{
BOOL fRet = FALSE;
if (pne->lEvent & SHCNE_ELIMINATE_DUPE_EVENTS)
{
// look for duplicates starting with the last one
for (int i = _dpaPendingEvents.GetPtrCount() - 1; !fRet && i >= 0; i--)
{
CNotifyEvent *pneMaybe = _dpaPendingEvents.FastGetPtr(i);
if (pne == pneMaybe)
fRet = TRUE;
else if ((pneMaybe->lEvent == pne->lEvent)
&& ILIsEqualOrBothNull(pne->pidl, pneMaybe->pidl, (pne->lEvent & SHCNE_GLOBALEVENTS))
&& ILIsEqualOrBothNull(pne->pidlExtra, pneMaybe->pidlExtra, (pneMaybe->lEvent & SHCNE_GLOBALEVENTS)))
fRet = TRUE;
}
}
return fRet;
}
BOOL CCollapsingClient::_AddEvent(CNotifyEvent *pneOld, BOOL fFromExtra)
{
CNotifyEvent *pne = pneOld;
pne->AddRef();
BOOL fCollapse = _CanCollapse(pne->lEvent);
if (fCollapse)
{
//
// If we get too many messages in the queue at any given time,
// we set the last message in the cue to be an UPDATEDIR that will
// stand for all messages that we cant fit because the queue is full.
//
BOOL fAddSelf = TRUE;
if (_fRecursive && _dpaPendingEvents.GetPtrCount() < (EVENT_OVERFLOW *2))
{
BOOL fFreeUpdate = FALSE;
LPITEMIDLIST pidlUpdate = fFromExtra ? pne->pidlExtra : pne->pidl;
DWORD dwAttrs = SFGAO_FOLDER;
SHGetNameAndFlags(pidlUpdate, 0, NULL, 0, &dwAttrs);
if (!(dwAttrs & SFGAO_FOLDER))
{
pidlUpdate = ILCloneParent(pidlUpdate);
fFreeUpdate = TRUE;
}
if (pidlUpdate)
{
if (ILGetSize(pidlUpdate) > ILGetSize(_pidl))
{
pne->Release();
// then we should add this folder to the update list
pne = g_pscn->GetEvent(SHCNE_UPDATEDIR, pidlUpdate, NULL, pne->dwEventTime, 0);
if (pne)
{
fAddSelf = FALSE;
}
}
if (fFreeUpdate)
ILFree(pidlUpdate);
}
}
if (fAddSelf && pne)
{
pne->Release();
pne = g_pscn->GetEvent(SHCNE_UPDATEDIR, _pidl, NULL, pne->dwEventTime, 0);
}
}
if (pne)
{
if (!_IsDupe(pne))
{
// if this is one of our special collapsed
// events then we force it in even if we are full
if ((fCollapse || _dpaPendingEvents.GetPtrCount() < EVENT_OVERFLOW)
&& _dpaPendingEvents.AppendPtr(pne) != -1)
{
pne->AddRef();
g_pscn->SetFlush(FLUSH_SOFT);
if (!_fUpdatingSelf && (pne->lEvent & SHCNE_UPDATEDIR) && ILIsEqualEx(_pidl, pne->pidl, TRUE, SHCIDS_CANONICALONLY))
{
_fUpdatingSelf = TRUE;
_iUpdatingSelfIndex = _dpaPendingEvents.GetPtrCount() - 1;
}
}
// if we are getting filesystem updates
// always pretend that we overflowed
// this is because UPDATEDIR's are the
// most expensive thing we do.
if (pne->lEvent & SHCNE_INTERRUPT)
{
TraceMsg(TF_SHELLCHANGENOTIFY, "SCN [0x%X]->_AddEvent adding interrupt", this);
_cEvents += EVENT_OVERFLOW;
}
// count all events even if they
// they werent added.
_cEvents++;
}
pne->Release();
}
return TRUE;
}
void CCollapsingClient::Notify(CNotifyEvent *pne, BOOL fFromExtra)
{
if (_WantsEvent(pne->lEvent))
{
_AddEvent(pne, fFromExtra);
}
}
//--------------------------------------------------------------------------
// Notifies hCallbackEvent when all the notification packets for
// all clients in this process have been handled.
//
// This function is primarily called from the FSNotifyThreadProc thread,
// but in flush cases, it can be called from the desktop thread
//
void CALLBACK _DispatchCallbackNoRef(HWND hwnd, UINT uiMsg,
DWORD_PTR dwParam, LRESULT result)
{
MSGEVENT *pme = (MSGEVENT *)dwParam;
SHChangeNotification_Destroy(pme->hChange, pme->dwProcId);
delete pme;
}
void CALLBACK _DispatchCallback(HWND hwnd, UINT uiMsg,
DWORD_PTR hChange, LRESULT result)
{
_DispatchCallbackNoRef(hwnd, uiMsg, hChange, result);
if (EVAL(g_pscn))
g_pscn->PendingCallbacks(FALSE);
}
void CChangeNotify::PendingCallbacks(BOOL fAdd)
{
if (fAdd)
{
_cCallbacks++;
ASSERT(_cCallbacks != 0);
//
// callback count must be non-zero, we just incremented it.
// Put the event into the reset/false state.
//
if (!_hCallbackEvent)
{
_hCallbackEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
}
else
{
ResetEvent(_hCallbackEvent);
}
}
else
{
//
// PERF: Waits like this happen on flush, but that really cares about flushing that thread
// only, and this hCallbackEvent is per-process. So that thread may be stuck
// waiting for some dead app to respond. Fortunately the wait is only 30 seconds,
// but some wedged window could really make the system crawl...
//
ASSERT(_cCallbacks != 0);
_cCallbacks--;
if (!_cCallbacks && _hCallbackEvent)
{
// we just got the last of our callbacks
// signal incase somebody is waiting
SetEvent(_hCallbackEvent);
}
}
}
BOOL CCollapsingClient::Flush(BOOL fNeedsCallbackEvent)
{
BOOL fRet = FALSE;
if (fNeedsCallbackEvent || _cEvents < EVENT_OVERFLOW)
{
TraceMsg(TF_SHELLCHANGENOTIFY, "SCN [0x%X]->Flush is completing", this);
fRet = _Flush(fNeedsCallbackEvent);
}
else
{
TraceMsg(TF_SHELLCHANGENOTIFY, "SCN [0x%X]->Flush is deferred", this);
g_pscn->SetFlush(FLUSH_OVERFLOW);
}
_cEvents = 0;
return fRet;
}
void CRegisteredClient::_SendNotification(CNotifyEvent *pne, BOOL fNeedsCallbackEvent, SENDASYNCPROC pfncb)
{
// we could possibly reuse one in some cases
MSGEVENT * pme = pne->GetNotification(_dwProcId);
if (pme)
{
if (fNeedsCallbackEvent)
{
g_pscn->PendingCallbacks(TRUE);
}
if (!SendMessageCallback(_hwnd, _wMsg,
(WPARAM)pme->hChange,
(LPARAM)_dwProcId,
pfncb,
(DWORD_PTR)pme))
{
pfncb(_hwnd, _wMsg, (DWORD_PTR)pme, 0);
TraceMsg(TF_WARNING, "(_SHChangeNotifyHandleClientEvents) SendMessageCB timed out");
// if the hwnd is bad, the process probably died,
// remove the window from future notifications.
if (!IsWindow(_hwnd))
{
_fDeadClient = TRUE;
// we failed to Flush
}
}
}
}
BOOL CCollapsingClient::_Flush(BOOL fNeedsCallbackEvent)
{
if (fNeedsCallbackEvent && _hwnd)
{
DWORD_PTR dwResult = 0;
fNeedsCallbackEvent = (0 != SendMessageTimeout(_hwnd, WM_NULL, 0, 0, SMTO_ABORTIFHUNG, 0, &dwResult));
}
SENDASYNCPROC pfncb = fNeedsCallbackEvent ? _DispatchCallback : _DispatchCallbackNoRef;
BOOL fProcessedAny = FALSE;
// as long as there are events keep pulling them out
while (_dpaPendingEvents.GetPtrCount())
{
//
// 2000JUL3 - ZekeL - remove each one from our dpa so that if we reenter
// a flush during the sendmessage, we wont reprocess the event
// this also allows for an event to be added to the dpa while
// we proccessing and still be flushed on this pass.
//
CNotifyEvent *pne = _dpaPendingEvents.DeletePtr(0);
if (pne)
{
fProcessedAny = TRUE;
// we never send this if we are dead
if (_IsValidClient())
{
//
// if we are about to refresh this client (_fUpdatingSelf)
// only send if we are looking at the UPDATEDIR of _pidl
// or if this event is not a disk event.
//
if (!_CheckUpdatingSelf()
|| (0 == _iUpdatingSelfIndex)
|| !(pne->lEvent & SHCNE_DISKEVENTS))
{
BOOL fPreCall = BOOLIFY(_fUpdatingSelf);
_SendNotification(pne, fNeedsCallbackEvent, pfncb);
if (_fUpdatingSelf && !fPreCall)
{
// we were re-entered while sending this notification and
// during the re-entered call we collapsed notifications.
// the _iUpdatingSelfIndex value was set without knowing
// that we were going to decrement it after unwinding.
// account for that now:
_iUpdatingSelfIndex++;
}
}
#ifdef DEBUG
if (_fUpdatingSelf && 0 == _iUpdatingSelfIndex)
{
// RIP because fault injection
// can make this fail
if (!ILIsEqual(_pidl, pne->pidl))
TraceMsg(TF_WARNING, "CCollapsingClient::_Flush() maybe mismatched _fUpdatingSelf");
}
#endif // DEBUG
}
_iUpdatingSelfIndex--;
pne->Release();
}
}
_fUpdatingSelf = FALSE;
return fProcessedAny;
}
HRESULT CChangeNotify::RemoveClient(LPCITEMIDLIST pidl, BOOL fInterrupt, CCollapsingClient *pclient)
{
HRESULT hr = S_OK;
// remove this boy from the tree
if (_ptreeClients)
{
hr = _ptreeClients->RemoveData(pidl, (INT_PTR)pclient);
if (fInterrupt)
ReleaseInterruptSource(pidl);
}
return hr;
}
BOOL CChangeNotify::AddClient(IDLDATAF flags, LPCITEMIDLIST pidl, BOOL *pfInterrupt, BOOL fRecursive, CCollapsingClient *pclient)
{
BOOL fRet = FALSE;
if (_InitTree(&_ptreeClients))
{
ASSERT(pclient);
if (SUCCEEDED(_ptreeClients->AddData(flags, pidl, (INT_PTR)pclient)))
{
fRet = TRUE;
// set up the interrupt events if desired
if (pfInterrupt && *pfInterrupt)
{
*pfInterrupt = AddInterruptSource(pidl, fRecursive);
}
}
}
return fRet;
}
LPITEMIDLIST _ILCloneInterruptID(LPCITEMIDLIST pidl)
{
LPITEMIDLIST pidlRet = NULL;
if (pidl)
{
TCHAR sz[MAX_PATH];
if (SHGetPathFromIDList(pidl, sz))
{
WIN32_FIND_DATA fd = {0};
fd.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
SHSimpleIDListFromFindData(sz, &fd, &pidlRet);
}
}
else // NULL is special for desktop
pidlRet = SHCloneSpecialIDList(NULL, CSIDL_DESKTOPDIRECTORY, FALSE);
return pidlRet;
}
CInterruptSource *CChangeNotify::_InsertInterruptSource(LPCITEMIDLIST pidl, BOOL fRecursive)
{
CLinkedNode<CInterruptSource> *p = new CLinkedNode<CInterruptSource>;
if (p)
{
IDLDATAF flags = fRecursive ? IDLDATAF_MATCH_RECURSIVE : IDLDATAF_MATCH_IMMEDIATE;
if (p->that.Init(pidl, fRecursive)
&& _listInterrupts.Insert(p))
{
if (SUCCEEDED(_ptreeInterrupts->AddData(flags, p->that.pidl, (INT_PTR)&p->that)))
{
return &p->that;
}
else
{
_listInterrupts.Remove(p);
delete p;
}
}
else
delete p;
}
return NULL;
}
BOOL CChangeNotify::AddInterruptSource(LPCITEMIDLIST pidlClient, BOOL fRecursive)
{
if (_InitTree(&_ptreeInterrupts))
{
LPITEMIDLIST pidl = _ILCloneInterruptID(pidlClient);
if (pidl)
{
CInterruptSource *pintc = NULL;
if (FAILED(_ptreeInterrupts->MatchOne(IDLDATAF_MATCH_EXACT, pidl, (INT_PTR*)&pintc, NULL)))
{
pintc = _InsertInterruptSource(pidl, fRecursive);
}
ILFree(pidl);
if (pintc)
{
pintc->cClients++;
return TRUE;
}
}
}
return FALSE;
}
void CChangeNotify::ReleaseInterruptSource(LPCITEMIDLIST pidlClient)
{
if (_ptreeInterrupts)
{
LPITEMIDLIST pidl = _ILCloneInterruptID(pidlClient);
if (pidl)
{
CInterruptSource *pintc;
if (SUCCEEDED(_ptreeInterrupts->MatchOne(IDLDATAF_MATCH_EXACT, pidl, (INT_PTR*)&pintc, NULL)))
{
if (--(pintc->cClients) == 0)
{
// if RemoveData fails, we have to leak the client so the tree doesnt point to freed memory.
if (SUCCEEDED(_ptreeInterrupts->RemoveData(pidl, (INT_PTR)pintc)))
{
CLinkedWalk<CInterruptSource> lw(&_listInterrupts);
while (lw.Step())
{
if (lw.That() == pintc)
{
lw.Delete();
break;
}
}
}
}
}
ILFree(pidl);
}
}
}
void CChangeNotify::_ActivateAliases(LPCITEMIDLIST pidl, BOOL fActivate)
{
if (_ptreeAliases)
{
CIDLMatchMany *pmany;
if (SUCCEEDED(_ptreeAliases->MatchMany(IDLDATAF_MATCH_RECURSIVE, pidl, &pmany)))
{
CAnyAlias *paa;
while (S_OK == pmany->Next((INT_PTR *)&paa, NULL))
{
paa->Activate(fActivate);
}
delete pmany;
}
}
}
ULONG CChangeNotify::_RegisterClient(HWND hwnd, int fSources, LONG fEvents, UINT wMsg, SHChangeNotifyEntry *pfsne)
{
ULONG ulRet = 0;
CLinkedNode<CRegisteredClient> *p = new CLinkedNode<CRegisteredClient>;
if (p)
{
if (p->that.Init(hwnd, fSources, fEvents, wMsg, pfsne))
{
IDLDATAF flags = IDLDATAF_MATCH_IMMEDIATE;
if (!pfsne->pidl || pfsne->fRecursive)
flags = IDLDATAF_MATCH_RECURSIVE;
if (_listClients.Insert(p)
&& AddClient( flags,
pfsne->pidl,
&(p->that._fInterrupt),
pfsne->fRecursive && (fSources & SHCNRF_RecursiveInterrupt),
SAFECAST(&p->that, CCollapsingClient *)))
{
#ifdef DEBUG
TCHAR szName[MAX_PATH];
SHGetNameAndFlags(p->that._pidl, 0, szName, ARRAYSIZE(szName), NULL);
TraceMsg(TF_SHELLCHANGENOTIFY, "SCN::RegCli() added %s [0x%X] id = %d", szName, p, p->that._ulID);
#endif
_ActivateAliases(pfsne->pidl, TRUE);
ulRet = p->that._ulID;
}
}
if (!ulRet)
{
_listClients.Remove(p);
delete p;
}
}
return ulRet;
}
BOOL CChangeNotify::_InitTree(CIDLTree**pptree)
{
if (!*pptree)
{
CIDLTree::Create(pptree);
}
return *pptree != NULL;
}
CNotifyEvent *CChangeNotify::GetEvent(LONG lEvent, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra, DWORD dwEventTime, UINT uEventFlags)
{
return CNotifyEvent::Create(lEvent, pidl, pidlExtra, dwEventTime, uEventFlags);
}
BOOL CChangeNotify::_DeregisterClient(CRegisteredClient *pclient)
{
TraceMsg(TF_SHELLCHANGENOTIFY, "SCN::RegCli() removing [0x%X] id = %d", pclient, pclient->_ulID);
if (SUCCEEDED(RemoveClient(pclient->_pidl, pclient->_fInterrupt, SAFECAST(pclient, CCollapsingClient *))))
{
_ActivateAliases(pclient->_pidl, FALSE);
return TRUE;
}
return FALSE;
}
BOOL CChangeNotify::_DeregisterClientByID(ULONG ulID)
{
BOOL fRet = FALSE;
CLinkedWalk <CRegisteredClient> lw(&_listClients);
while (lw.Step())
{
if (lw.That()->_ulID == ulID)
{
// if we are flushing,
// then this is coming in while
// we are in SendMessageTimeout()
if (!_cFlushing)
{
fRet = _DeregisterClient(lw.That());
if (fRet)
{
lw.Delete();
}
}
else
lw.That()->_fDeadClient = TRUE;
break;
}
}
return fRet;
}
BOOL CChangeNotify::_DeregisterClientsByWindow(HWND hwnd)
{
BOOL fRet = FALSE;
CLinkedWalk <CRegisteredClient> lw(&_listClients);
while (lw.Step())
{
if (lw.That()->_hwnd == hwnd)
{
// if we are flushing,
// then this is coming in while
// we are in SendMessageTimeout()
if (!_cFlushing)
{
fRet = _DeregisterClient(lw.That());
if (fRet)
{
lw.Delete();
}
}
else
lw.That()->_fDeadClient = TRUE;
}
}
return fRet;
}
void CChangeNotify::_AddGlobalEvent(CNotifyEvent *pne)
{
CLinkedWalk <CRegisteredClient> lw(&_listClients);
while (lw.Step())
{
lw.That()->Notify(pne, FALSE);
}
// this is the notify we get when a drive mapping is deleted
// when this happens we need to kill the aliases to that drive
if ((pne->lEvent == SHCNE_DRIVEREMOVED) && !(pne->uEventFlags & SHCNF_TRANSLATEDALIAS))
{
CLinkedWalk<CAnyAlias> lw(&_listAliases);
while (lw.Step())
{
lw.That()->Notify(pne, FALSE);
}
}
}
void CChangeNotify::_MatchAndNotify(LPCITEMIDLIST pidl, CNotifyEvent *pne, BOOL fFromExtra)
{
if (_ptreeClients)
{
CIDLMatchMany *pmany;
if (SUCCEEDED(_ptreeClients->MatchMany(IDLDATAF_MATCH_RECURSIVE, pidl, &pmany)))
{
CCollapsingClient *pclient;
while (S_OK == pmany->Next((INT_PTR *)&pclient, NULL))
{
pclient->Notify(pne, fFromExtra);
}
delete pmany;
}
}
}
BOOL CChangeNotify::_AddToClients(LONG lEvent, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra, DWORD dwEventTime, UINT uEventFlags)
{
BOOL bOnlyUpdateDirs = TRUE;
CNotifyEvent *pne = GetEvent(lEvent, pidl, pidlExtra, dwEventTime, uEventFlags);
if (pne)
{
if (lEvent & SHCNE_GLOBALEVENTS)
{
_AddGlobalEvent(pne);
}
else
{
_MatchAndNotify(pidl, pne, FALSE);
if (pidlExtra)
_MatchAndNotify(pidlExtra, pne, TRUE);
}
pne->Release();
}
return bOnlyUpdateDirs;
}
BOOL CChangeNotify::_HandleMessages(void)
{
MSG msg;
// There was some message put in our queue, so we need to dispose
// of it
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
if (msg.hwnd)
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
switch (msg.message)
{
case SCNM_TERMINATE:
DestroyWindow(g_hwndSCN);
g_hwndSCN = NULL;
return TRUE;
break;
default:
TraceMsg(TF_SHELLCHANGENOTIFY, "SCN thread proc: eating unknown message %#lx", msg.message);
break;
}
}
}
return FALSE;
}
CInterruptSource::~CInterruptSource()
{
_Reset(TRUE);
ILFree(pidl);
}
BOOL CInterruptSource::Init(LPCITEMIDLIST pidl, BOOL fRecursive)
{
this->pidl = ILClone(pidl);
_fRecursive = fRecursive;
return (this->pidl != NULL);
}
BOOL CInterruptSource::Flush(void)
{
if (FS_SIGNAL == _ssSignal)
{
g_pscn->NotifyEvent(SHCNE_UPDATEDIR | SHCNE_INTERRUPT, SHCNF_IDLIST, pidl, NULL, GetTickCount());
}
_ssSignal = NO_SIGNAL;
return TRUE;
}
void CInterruptSource::_Reset(BOOL fDeviceNotify)
{
if (_hEvent && _hEvent != INVALID_HANDLE_VALUE)
{
FindCloseChangeNotification(_hEvent);
_hEvent = NULL;
}
if (fDeviceNotify && _hPNP)
{
UnregisterDeviceNotification(_hPNP);
_hPNP = NULL;
}
}
void CInterruptSource::Reset(BOOL fSignal)
{
if (fSignal) // file system event
{
switch(_ssSignal)
{
case NO_SIGNAL: _ssSignal = FS_SIGNAL; break;
case SH_SIGNAL: _ssSignal = NO_SIGNAL; break;
}
if (!FindNextChangeNotification(_hEvent))
{
_Reset(FALSE);
// when we fail, we dont want
// to retry. which we will do
// in the case of _hEvent = NULL;
_hEvent = INVALID_HANDLE_VALUE;
}
}
else // shell event
{
switch(_ssSignal)
{
case NO_SIGNAL: _ssSignal = SH_SIGNAL; break;
case FS_SIGNAL: _ssSignal = NO_SIGNAL; break;
}
}
}
#define FFCN_INTERESTING_EVENTS (FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_ATTRIBUTES)
BOOL CInterruptSource::GetEvent(HANDLE *phEvent)
{
if (_cSuspend == 0 && cClients)
{
// create this here so that it will be owned by our global thread
if (!_hEvent)
{
TCHAR szPath[MAX_PATH];
if (SHGetPathFromIDList(pidl, szPath))
{
_hEvent = FindFirstChangeNotification(szPath, _fRecursive, FFCN_INTERESTING_EVENTS);
if (_hEvent != INVALID_HANDLE_VALUE)
{
// PERF optimization alert: RegisterDeviceNotification is being used for removable drives
// to ensure that the FindFirstChangeNotification call will not prevent the disk
// from being ejected or dismounted. However, RegisterDeviceNotification is a very expensive
// call to make at startup as it brings a bunch of DLLs in the address space. Besides,
// we really don't need to call this for the system drive since it needs to remain
// mounted at all times. - FabriceD
// Exclude FIXED drives too
int iDrive = PathGetDriveNumber(szPath);
int nType = DRIVE_UNKNOWN;
if (iDrive != -1)
{
nType = DriveType(iDrive);
}
// PERF: Exclude the system drive from the RegisterDeviceNotification calls.
TCHAR chDrive = *szPath;
if ((!GetEnvironmentVariable(TEXT("SystemDrive"), szPath, ARRAYSIZE(szPath)) || *szPath != chDrive) &&
nType != DRIVE_FIXED)
{
// DO WE NEED TO UnRegister() first?
DEV_BROADCAST_HANDLE dbh;
ZeroMemory(&dbh, sizeof(dbh));
dbh.dbch_size = sizeof(dbh);
dbh.dbch_devicetype = DBT_DEVTYP_HANDLE;
dbh.dbch_handle = _hEvent;
_hPNP = RegisterDeviceNotification(g_hwndSCN, &dbh, DEVICE_NOTIFY_WINDOW_HANDLE);
}
}
}
else
_hEvent = INVALID_HANDLE_VALUE;
}
if (_hEvent != INVALID_HANDLE_VALUE)
{
*phEvent = _hEvent;
return TRUE;
}
}
return FALSE;
}
void CChangeNotify::_SignalInterrupt(HANDLE hEvent)
{
CLinkedWalk<CInterruptSource> lw(&_listInterrupts);
while (lw.Step())
{
// searching for valid clients
HANDLE h;
if (lw.That()->GetEvent(&h) && h == hEvent)
{
g_pscn->SetFlush(FLUSH_INTERRUPT);
lw.That()->Reset(TRUE);
break;
}
}
}
DWORD CChangeNotify::_GetInterruptEvents(HANDLE *ahEvents, DWORD cEventsSize)
{
DWORD cEvents = 0;
CLinkedWalk<CInterruptSource> lw(&_listInterrupts);
while (cEvents < cEventsSize && lw.Step())
{
// go through and find all the valid
// clients that need waiting on
if (lw.That()->GetEvent(&ahEvents[cEvents]))
{
// lw.That()->Reset(FALSE);
cEvents++;
}
}
return cEvents;
}
void CChangeNotify::_MessagePump(void)
{
DWORD cFails = 0;
while (TRUE)
{
HANDLE ahEvents[MAXIMUM_WAIT_OBJECTS - 1];
DWORD cEvents = _GetInterruptEvents(ahEvents, ARRAYSIZE(ahEvents));
// maybe cache the events?
// NEED to handle pending Events with a Timer
DWORD dwWaitResult = MsgWaitForMultipleObjectsEx(cEvents, ahEvents,
INFINITE, QS_ALLINPUT, MWMO_ALERTABLE);
if (dwWaitResult != (DWORD)-1)
{
if (dwWaitResult != WAIT_IO_COMPLETION)
{
dwWaitResult -= WAIT_OBJECT_0;
if (dwWaitResult == cEvents)
{
// there is a message
if (_HandleMessages())
break;
}
else if (dwWaitResult < cEvents)
{
_SignalInterrupt(ahEvents[dwWaitResult]);
}
}
cFails = 0;
}
else
{
// there was some kind of error
TraceMsg(TF_ERROR, "SCNotify WaitForMulti() failed with %d", GetLastError());
// if MWFM() fails over and over, we give up.
if (++cFails > 10)
{
TraceMsg(TF_ERROR, "SCNotify WaitForMulti() bailing out");
break;
}
}
}
}
void SCNUninitialize(void)
{
if (g_pscn)
{
if (IsWindow(g_hwndSCN))
DestroyWindow(g_hwndSCN);
g_hwndSCN = NULL;
delete g_pscn;
g_pscn = NULL;
}
}
// the real thread proc, runs after CChangeNotify::ThreadStartUp runs sync
DWORD WINAPI CChangeNotify::ThreadProc(void *pv)
{
if (g_pscn)
{
CMountPoint::RegisterForHardwareNotifications();
#ifdef RESTARTSCN
__try
#endif
{
g_pscn->_MessagePump();
}
#ifdef RESTARTSCN
__except (EXCEPTION_EXECUTE_HANDLER)
{
ASSERT(FALSE);
}
#endif
}
SCNUninitialize();
return 0;
}
BOOL CChangeNotify::_OnChangeRegistration(HANDLE hChangeRegistration, DWORD dwProcId)
{
BOOL fResult = FALSE;
CHANGEREGISTER *pcr = (CHANGEREGISTER *)SHLockSharedEx(hChangeRegistration, dwProcId, TRUE);
if (pcr)
{
SHChangeNotifyEntry fsne;
fsne.pidl = NULL;
fsne.fRecursive = pcr->fRecursive;
if (pcr->uidlRegister)
fsne.pidl = _ILSkip(pcr, pcr->uidlRegister);
pcr->ulID = _RegisterClient((HWND)ULongToPtr(pcr->ulHwnd), pcr->fSources,
pcr->lEvents, pcr->uMsg, &fsne);
fResult = TRUE;
SHUnlockShared(pcr);
}
return fResult;
}
void CChangeNotify::_ResetRelatedInterrupts(LPCITEMIDLIST pidl)
{
if (_ptreeInterrupts)
{
// we need to match whoever listens on this pidl
CIDLMatchMany *pmany;
if (SUCCEEDED(_ptreeInterrupts->MatchMany(IDLDATAF_MATCH_RECURSIVE, pidl, &pmany)))
{
CInterruptSource *pintc;
while (S_OK == pmany->Next((INT_PTR *)&pintc, NULL))
{
// we might need WFSO(pintc->GetEvent()) here first
// if this is already signaled,
// we need to unsignal
pintc->Reset(FALSE);
}
delete pmany;
}
}
}
void CChangeNotify::_FlushInterrupts(void)
{
CLinkedWalk<CInterruptSource> lw(&_listInterrupts);
while (lw.Step())
{
lw.That()->Flush();
}
}
#define CALLBACK_TIMEOUT 30000 // 30 seconds
void CChangeNotify::_WaitForCallbacks(void)
{
while (_cCallbacks && _hCallbackEvent)
{
MSG msg;
DWORD dwWaitResult = MsgWaitForMultipleObjects(1, &_hCallbackEvent, FALSE,
CALLBACK_TIMEOUT, QS_SENDMESSAGE);
TraceMsg(TF_SHELLCHANGENOTIFY, "FSN_WaitForCallbacks returned 0x%X", dwWaitResult);
if (dwWaitResult == WAIT_OBJECT_0) break; // Event completed
if (dwWaitResult == WAIT_TIMEOUT) break; // Ran out of time
if (dwWaitResult == WAIT_OBJECT_0+1)
{
//
// Some message came in, reset message event, deliver callbacks, etc.
//
PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE); // we need to do this to flush callbacks
}
}
if (_hCallbackEvent)
{
CloseHandle(_hCallbackEvent);
_hCallbackEvent = NULL;
}
}
void CChangeNotify::SetFlush(int idt)
{
switch (idt)
{
case FLUSH_OVERFLOW:
case FLUSH_SOFT:
SetTimer(g_hwndSCN, IDT_SCN_FLUSHEVENTS, 500, NULL);
break;
case FLUSH_HARD:
PostMessage(g_hwndSCN, SCNM_FLUSHEVENTS, 0, 0);
break;
case FLUSH_INTERRUPT:
SetTimer(g_hwndSCN, IDT_SCN_FLUSHEVENTS, 1000, NULL);
break;
}
}
void CChangeNotify::_Flush(BOOL fShouldWait)
{
_cFlushing++;
KillTimer(g_hwndSCN, IDT_SCN_FLUSHEVENTS);
// flush any pending interrupt events
_FlushInterrupts();
int iNumLoops = 0;
BOOL fProcessedAny;
do
{
fProcessedAny = FALSE;
CLinkedWalk<CAnyAlias> lwAliases(&_listAliases);
while (lwAliases.Step())
{
if (lwAliases.That()->Flush(TRUE))
{
fProcessedAny = TRUE;
}
}
iNumLoops++;
// in free builds bail out if there's a loop so we don't spin the thread.
// but this is pretty bad so assert anyway (the most people would usually have
// is 2 -- a folder shortcut to something on the desktop / mydocs)
ASSERTMSG(iNumLoops < 10, "we're in an alias loop, we're screwed");
} while (fProcessedAny && (iNumLoops < 10));
CLinkedWalk<CRegisteredClient> lwRegistered(&_listClients);
while (lwRegistered.Step())
{
lwRegistered.That()->Flush(fShouldWait);
}
if (fShouldWait)
{
// now wait for all the callbacks to empty out
_WaitForCallbacks();
}
_cFlushing--;
// wait until we have 10 seconds of free time
SetTimer(g_hwndSCN, IDT_SCN_FRESHENTREES, 10000, NULL);
}
BOOL IsILShared(LPCITEMIDLIST pidl, BOOL fUpdateCache)
{
TCHAR szTemp[MAXPATHLEN];
SHGetPathFromIDList(pidl, szTemp);
return IsShared(szTemp, fUpdateCache);
}
void CChangeNotify::NotifyEvent(LONG lEvent, UINT uFlags, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra, DWORD dwEventTime)
{
if (!(uFlags & SHCNF_ONLYNOTIFYINTERNALS) && lEvent)
{
/// now do the actual generating of the event
if (lEvent & (SHCNE_NETSHARE | SHCNE_NETUNSHARE))
{
// Update the cache.
IsILShared(pidl, TRUE);
}
_AddToClients(lEvent, pidl, pidlExtra, dwEventTime, uFlags);
// remove any shell generated events for the file system
if ((lEvent & SHCNE_DISKEVENTS) &&
!(lEvent & (SHCNE_INTERRUPT | SHCNE_UPDATEDIR)))
{
_ResetRelatedInterrupts(pidl);
if (pidlExtra)
_ResetRelatedInterrupts(pidlExtra);
}
}
// note make sure the internal events go first.
if (lEvent)
NotifyShellInternals(lEvent, uFlags, pidl, pidlExtra, dwEventTime);
//
// then the registered events
//
if (uFlags & (SHCNF_FLUSH))
{
if (uFlags & SHCNF_FLUSHNOWAIT)
{
SetFlush(FLUSH_HARD);
}
else
_Flush(TRUE);
}
}
LRESULT CChangeNotify::_OnNotifyEvent(HANDLE hChange, DWORD dwProcId)
{
CHANGELOCK *pcl = _SHChangeNotification_Lock(hChange, dwProcId);
if (pcl)
{
NotifyEvent(pcl->pce->lEvent,
pcl->pce->uFlags,
pcl->pidlMain,
pcl->pidlExtra,
pcl->pce->dwEventTime);
SHChangeNotification_Unlock(pcl);
SHChangeNotification_Destroy(hChange, dwProcId);
}
return TRUE;
}
void CInterruptSource::Suspend(BOOL fSuspend)
{
if (fSuspend)
{
if (!_cSuspend)
_Reset(FALSE);
_cSuspend++;
}
else if (_cSuspend)
_cSuspend--;
}
BOOL CChangeNotify::_SuspendResume(BOOL fSuspend, BOOL fRecursive, LPCITEMIDLIST pidl)
{
if (_ptreeInterrupts)
{
CInterruptSource *pintc;
if (!fRecursive)
{
if (SUCCEEDED(_ptreeInterrupts->MatchOne(IDLDATAF_MATCH_EXACT, pidl, (INT_PTR*)&pintc, NULL)))
{
pintc->Suspend(fSuspend);
}
}
else
{
CIDLMatchMany *pmany;
if (SUCCEEDED(_ptreeInterrupts->MatchMany(IDLDATAF_MATCH_RECURSIVE, pidl, &pmany)))
{
while (S_OK == pmany->Next((INT_PTR *)&pintc, NULL))
{
pintc->Suspend(fSuspend);
}
delete pmany;
}
}
}
return TRUE;
}
#define SCNSUSPEND_SUSPEND 1
#define SCNSUSPEND_RECURSIVE 2
LRESULT CChangeNotify::_OnSuspendResume(HANDLE hChange, DWORD dwProcId)
{
BOOL fRet = FALSE;
CHANGELOCK *pcl = _SHChangeNotification_Lock(hChange, dwProcId);
if (pcl)
{
fRet = _SuspendResume(pcl->pce->uFlags & SCNSUSPEND_SUSPEND, pcl->pce->uFlags & SCNSUSPEND_RECURSIVE, pcl->pidlMain);
SHChangeNotification_Unlock((HANDLE)pcl);
}
return fRet;
}
BOOL CInterruptSource::SuspendDevice(BOOL fSuspend, HDEVNOTIFY hPNP)
{
BOOL fRet = FALSE;
if (hPNP)
{
if (fSuspend && _hPNP == hPNP)
{
_hSuspended = _hPNP;
Suspend(fSuspend);
_Reset(TRUE);
fRet = TRUE;
}
else if (!fSuspend && _hSuspended == hPNP)
{
_hSuspended = NULL;
Suspend(fSuspend);
fRet = TRUE;
}
}
else if (_hPNP)
{
// NULL means we are shutting down and should close all handles.
UnregisterDeviceNotification(_hPNP);
_hPNP = NULL;
}
return fRet;
}
// __HandleDevice
void CChangeNotify::_OnDeviceBroadcast(ULONG_PTR code, DEV_BROADCAST_HANDLE *pbhnd)
{
if (IsWindowVisible(GetShellWindow()) && pbhnd
&& (pbhnd->dbch_devicetype == DBT_DEVTYP_HANDLE && pbhnd->dbch_hdevnotify))
{
BOOL fSuspend;
switch (code)
{
// When PnP is finished messing with the drive (either successfully
// or unsuccessfully), resume notifications on that drive.
case DBT_DEVICEREMOVECOMPLETE:
case DBT_DEVICEQUERYREMOVEFAILED:
fSuspend = FALSE;
break;
// When PnP is starting to mess with the drive, suspend notifications
// so it can do its thing
case DBT_DEVICEQUERYREMOVE:
// This will wait on another thread to exit if this hdevnotify
// was registered for a Sniffing Dialog
CSniffDrive::HandleNotif(pbhnd->dbch_hdevnotify);
fSuspend = TRUE;
break;
case DBT_CUSTOMEVENT:
if (GUID_IO_VOLUME_LOCK == pbhnd->dbch_eventguid)
{
TraceMsg(TF_MOUNTPOINT, "GUID_IO_VOLUME_LOCK: Suspending!");
fSuspend = TRUE;
}
else
{
if (GUID_IO_VOLUME_LOCK_FAILED == pbhnd->dbch_eventguid)
{
TraceMsg(TF_MOUNTPOINT, "GUID_IO_VOLUME_LOCK_FAILED: Resuming!");
fSuspend = FALSE;
}
else
{
if (GUID_IO_VOLUME_UNLOCK == pbhnd->dbch_eventguid)
{
TraceMsg(TF_MOUNTPOINT, "GUID_IO_VOLUME_UNLOCK: Resuming!");
fSuspend = FALSE;
}
}
}
break;
default:
// we dont handle anything else here
return;
}
CLinkedWalk<CInterruptSource> lw(&_listInterrupts);
while (lw.Step())
{
// returns true if found
if (lw.That()->SuspendDevice(fSuspend, pbhnd->dbch_hdevnotify))
break;
}
}
}
void CChangeNotify::_FreshenClients(void)
{
CLinkedWalk<CRegisteredClient> lw(&_listClients);
while (lw.Step())
{
if (lw.That()->_fDeadClient || !IsWindow(lw.That()->_hwnd))
{
if (_DeregisterClient(lw.That()))
{
lw.Delete();
}
}
}
}
void CChangeNotify::_FreshenUp(void)
{
ASSERT(!_cFlushing);
KillTimer(g_hwndSCN, IDT_SCN_FRESHENTREES);
if (_ptreeClients)
_ptreeClients->Freshen();
if (_ptreeInterrupts)
_ptreeInterrupts->Freshen();
_FreshenAliases();
_FreshenClients();
}
LRESULT CChangeNotify::WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LRESULT lRes = 0;
ASSERT(g_pscn);
switch (uMsg)
{
case SCNM_REGISTERCLIENT:
lRes = g_pscn->_OnChangeRegistration((HANDLE)wParam, (DWORD)lParam);
break;
case SCNM_DEREGISTERCLIENT:
lRes = g_pscn->_DeregisterClientByID((ULONG)wParam);
break;
case SCNM_DEREGISTERWINDOW:
lRes = g_pscn->_DeregisterClientsByWindow((HWND)wParam);
break;
case SCNM_NOTIFYEVENT:
lRes = g_pscn->_OnNotifyEvent((HANDLE)wParam, (DWORD)lParam);
break;
case SCNM_SUSPENDRESUME:
lRes = g_pscn->_OnSuspendResume((HANDLE)wParam, (DWORD)lParam);
break;
case WM_TIMER:
if (wParam == IDT_SCN_FRESHENTREES)
{
g_pscn->_FreshenUp();
break;
}
// Fall through to SCNM_FLUSHEVENTS
case SCNM_FLUSHEVENTS:
g_pscn->_Flush(FALSE);
break;
case SCNM_AUTOPLAYDRIVE:
CMountPoint::DoAutorunPrompt(wParam);
break;
case WM_DEVICECHANGE:
g_pscn->_OnDeviceBroadcast(wParam, (DEV_BROADCAST_HANDLE *)lParam);
break;
default:
lRes = DefWindowProc(hwnd, uMsg, wParam, lParam);
break;
}
return lRes;
}
// thread setup routine, executed before SHCreateThread() returns
DWORD WINAPI CChangeNotify::ThreadStartUp(void *pv)
{
g_pscn = new CChangeNotify();
if (g_pscn)
{
g_hwndSCN = SHCreateWorkerWindow(CChangeNotify::WndProc, NULL, 0, 0, NULL, g_pscn);
CSniffDrive::InitNotifyWindow(g_hwndSCN);
InitAliasFolderTable();
}
return 0;
}
// now we create the window
BOOL SCNInitialize()
{
EnterCriticalSection(&g_csSCN);
if (!IsWindow(g_hwndSCN))
{
SHCreateThread(CChangeNotify::ThreadProc, NULL, CTF_COINIT, CChangeNotify::ThreadStartUp);
}
LeaveCriticalSection(&g_csSCN);
return g_hwndSCN ? TRUE : FALSE; // ThreadStartUp is executed sync
}
BOOL _IsImpersonating()
{
HANDLE hToken;
if (OpenThreadToken(GetCurrentThread(), TOKEN_QUERY | TOKEN_IMPERSONATE, TRUE, &hToken))
{
CloseHandle(hToken);
return TRUE;
}
return FALSE;
}
STDAPI_(HWND) _SCNGetWindow(BOOL fUseDesktop, BOOL fNeedsFallback)
{
// if explorer is trashed
// then this hwnd can go bad
// get a new copy from the desktop
if (!g_hwndSCN || !IsWindow(g_hwndSCN))
{
HWND hwndDesktop = fUseDesktop ? GetShellWindow() : NULL;
if (hwndDesktop)
{
HWND hwndSCN = (HWND) SendMessage(hwndDesktop, CWM_GETSCNWINDOW, 0, 0);
if (_IsImpersonating())
return hwndSCN;
else
g_hwndSCN = hwndSCN;
}
else if (fNeedsFallback && SHIsCurrentThreadInteractive())
{
// there is no desktop.
// so we create a private desktop
// this will create the thread and window
// and set
SCNInitialize();
}
}
return g_hwndSCN;
}
STDAPI_(HWND) SCNGetWindow(BOOL fUseDesktop)
{
return _SCNGetWindow(fUseDesktop, TRUE);
}
HANDLE SHChangeRegistration_Create(ULONG ulID,
HWND hwnd, UINT uMsg,
DWORD fSources, LONG lEvents,
BOOL fRecursive, LPCITEMIDLIST pidl,
DWORD dwProcId)
{
UINT uidlSize = ILGetSize(pidl);
HANDLE hReg = SHAllocShared(NULL, sizeof(CHANGEREGISTER) + uidlSize, dwProcId);
if (hReg)
{
CHANGEREGISTER *pcr = (CHANGEREGISTER *) SHLockSharedEx(hReg, dwProcId, TRUE);
if (pcr)
{
pcr->dwSig = CHANGEREGISTER_SIG;
pcr->ulID = ulID;
pcr->ulHwnd = PtrToUlong(hwnd);
pcr->uMsg = uMsg;
pcr->fSources = fSources;
pcr->lEvents = lEvents;
pcr->fRecursive = fRecursive;
pcr->uidlRegister = 0;
if (pidl)
{
pcr->uidlRegister = sizeof(CHANGEREGISTER);
memcpy((pcr + 1), pidl, uidlSize);
}
SHUnlockShared(pcr);
}
else
{
SHFreeShared(hReg, dwProcId);
hReg = NULL;
}
}
return hReg;
}
typedef struct
{
HWND hwnd;
UINT wMsg;
} NOTIFY_PROXY_DATA;
#define WM_CHANGENOTIFYMSG WM_USER + 1
LRESULT CALLBACK _HiddenNotifyWndProc(HWND hWnd, UINT iMessage, WPARAM wParam, LPARAM lParam)
{
LRESULT lRes = FALSE;
NOTIFY_PROXY_DATA *pData = (NOTIFY_PROXY_DATA *) GetWindowLongPtr( hWnd, 0 );
switch (iMessage)
{
case WM_NCDESTROY:
ASSERT(pData != NULL );
// clear it so it won't be in use....
SetWindowLongPtr( hWnd, 0, (LONG_PTR)NULL );
// free the memory ...
LocalFree( pData );
break;
case WM_CHANGENOTIFYMSG :
if (pData)
{
// lock and break the info structure ....
LPITEMIDLIST *ppidl;
LONG lEvent;
HANDLE hLock = SHChangeNotification_Lock((HANDLE)wParam, (DWORD)lParam, &ppidl, &lEvent);
if (hLock)
{
// pass on to the old style client. ...
lRes = SendMessage( pData->hwnd, pData->wMsg, (WPARAM) ppidl, (LPARAM) lEvent );
// new notifications ......
SHChangeNotification_Unlock(hLock);
}
}
break;
default:
lRes = DefWindowProc(hWnd, iMessage, wParam, lParam);
break;
}
return lRes;
}
HWND _CreateProxyWindow(HWND hwnd, UINT wMsg)
{
HWND hwndRet = NULL;
// This is an old style notification, we need to create a hidden
// proxy type of window to properly handle the messages...
NOTIFY_PROXY_DATA *pnpd = (NOTIFY_PROXY_DATA *)LocalAlloc(LPTR, sizeof(*pnpd));
if (pnpd)
{
pnpd->hwnd = hwnd;
pnpd->wMsg = wMsg;
hwndRet = SHCreateWorkerWindow(_HiddenNotifyWndProc, NULL, 0, 0, NULL, pnpd);
if (!hwndRet)
LocalFree(pnpd);
}
return hwndRet;
}
//--------------------------------------------------------------------------
//
// Returns a positive integer registration ID, or 0 if out of memory or if
// invalid parameters were passed in.
//
// If the hwnd is != NULL we do a PostMessage(hwnd, wMsg, ...) when a
// relevant FS event takes place, otherwise if fsncb is != NULL we call it.
//
STDAPI_(ULONG) SHChangeNotifyRegister(HWND hwnd,
int fSources, LONG fEvents,
UINT wMsg, int cEntries,
SHChangeNotifyEntry *pfsne)
{
ULONG ulID = 0;
BOOL fResult = FALSE;
HWND hwndSCN = SCNGetWindow(TRUE);
if (hwndSCN)
{
if (!(fSources & SHCNRF_NewDelivery))
{
// Now setup to use the proxy window instead
hwnd = _CreateProxyWindow(hwnd, wMsg);
wMsg = WM_CHANGENOTIFYMSG;
}
if ((fSources & SHCNRF_RecursiveInterrupt) && !(fSources & SHCNRF_InterruptLevel))
{
// bad caller, they asked for recursive interrupt events, but not interrupt events
ASSERTMSG(FALSE, "SHChangeNotifyRegister: caller passed SHCNRF_RecursiveInterrupt but NOT SHCNRF_InterruptLevel !!");
// clear the flag
fSources = fSources & (~SHCNRF_RecursiveInterrupt);
}
// This same assert is CRegisteredClient::Init, caled by SCNM_REGISTERCLIENT message below
ASSERT(fSources & (SHCNRF_InterruptLevel | SHCNRF_ShellLevel));
// NOTE - if we have more than one registration entry here,
// we only support Deregister'ing the last one
for (int i = 0; i < cEntries; i++)
{
DWORD dwProcId;
GetWindowThreadProcessId(hwndSCN, &dwProcId);
HANDLE hChangeRegistration = SHChangeRegistration_Create(
ulID, hwnd, wMsg,
fSources, fEvents,
pfsne[i].fRecursive, pfsne[i].pidl,
dwProcId);
if (hChangeRegistration)
{
CHANGEREGISTER * pcr;
//
// Transmit the change regsitration
//
SendMessage(hwndSCN, SCNM_REGISTERCLIENT,
(WPARAM)hChangeRegistration, (LPARAM)dwProcId);
//
// Now get back the ulID value, for further registrations and
// for returning to the calling function...
//
pcr = (CHANGEREGISTER *)SHLockSharedEx(hChangeRegistration, dwProcId, FALSE);
if (pcr)
{
ulID = pcr->ulID;
SHUnlockShared(pcr);
}
else
{
ASSERT(0 == ulID); // Error condition initialized above
}
SHFreeShared(hChangeRegistration, dwProcId);
}
if ((ulID == 0) && !(fSources & SHCNRF_NewDelivery))
{
// this is our proxy window
DestroyWindow(hwnd);
break;
}
}
}
return ulID;
}
//--------------------------------------------------------------------------
//
// Returns TRUE if we found and removed the specified Client, otherwise
// returns FALSE.
//
STDAPI_(BOOL) SHChangeNotifyDeregister(ULONG ulID)
{
BOOL fResult = FALSE;
HWND hwnd = _SCNGetWindow(TRUE, FALSE);
if (hwnd)
{
//
// Transmit the change registration
//
fResult = (BOOL) SendMessage(hwnd, SCNM_DEREGISTERCLIENT, ulID, 0);
}
return fResult;
}
// send the notify to the desktop... telling it to put it in the queue.
// if we are in the desktop's process, we can handle it directly ourselves.
// the one exception is flush. we want the desktop to be one serializing flush so
// we send in that case as well
void SHChangeNotifyTransmit(LONG lEvent, UINT uFlags, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra, DWORD dwEventTime)
{
HWND hwndSCN = _SCNGetWindow(TRUE, FALSE);
if (hwndSCN)
{
DWORD dwProcId;
GetWindowThreadProcessId(hwndSCN, &dwProcId);
HANDLE hChange = SHChangeNotification_Create(lEvent, uFlags, pidl, pidlExtra, dwProcId, dwEventTime);
if (hChange)
{
BOOL fFlushNow = ((uFlags & (SHCNF_FLUSH | SHCNF_FLUSHNOWAIT)) == SHCNF_FLUSH);
// Flush but not flush no wait
if (fFlushNow)
{
SendMessage(hwndSCN, SCNM_NOTIFYEVENT,
(WPARAM)hChange, (LPARAM)dwProcId);
}
else
{
SendNotifyMessage(hwndSCN, SCNM_NOTIFYEVENT,
(WPARAM)hChange, (LPARAM)dwProcId);
}
}
}
}
void FreeSpacePidlToPath(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
TCHAR szPath1[MAX_PATH];
if (SHGetPathFromIDList(pidl1, szPath1))
{
TCHAR szPath2[MAX_PATH];
szPath2[0] = 0;
if (pidl2)
{
SHGetPathFromIDList(pidl2, szPath2);
}
SHChangeNotify(SHCNE_FREESPACE, SHCNF_PATH, szPath1, szPath2[0] ? szPath2 : NULL);
}
}
STDAPI_(void) SHChangeNotify(LONG lEvent, UINT uFlags, const void * dwItem1, const void * dwItem2)
{
if (!_SCNGetWindow(TRUE, FALSE))
return;
LPCITEMIDLIST pidl = NULL;
LPCITEMIDLIST pidlExtra = NULL;
LPITEMIDLIST pidlFree = NULL;
LPITEMIDLIST pidlExtraFree = NULL;
UINT uType = uFlags & SHCNF_TYPE;
SHChangeDWORDAsIDList dwidl;
BOOL fPrinter = FALSE;
BOOL fPrintJob = FALSE;
DWORD dwEventTime = GetTickCount();
// first setup anything the flags request
switch (uType)
{
case SHCNF_PRINTJOBA:
fPrintJob = TRUE;
// fall through
case SHCNF_PRINTERA:
fPrinter = TRUE;
// fall through
case SHCNF_PATHA:
{
TCHAR szPath1[MAX_PATH], szPath2[MAX_PATH];
LPCVOID pvItem1 = NULL;
LPCVOID pvItem2 = NULL;
if (dwItem1)
{
SHAnsiToTChar((LPSTR)dwItem1, szPath1, ARRAYSIZE(szPath1));
pvItem1 = szPath1;
}
if (dwItem2)
{
if (fPrintJob)
pvItem2 = dwItem2; // SHCNF_PRINTJOB_DATA needs no conversion
else
{
SHAnsiToTChar((LPSTR)dwItem2, szPath2, ARRAYSIZE(szPath2));
pvItem2 = szPath2;
}
}
SHChangeNotify(lEvent, (fPrintJob ? SHCNF_PRINTJOB : (fPrinter ? SHCNF_PRINTER : SHCNF_PATH)),
pvItem1, pvItem2);
goto Cleanup; // Let the recursive version do all the work
}
break;
case SHCNF_PATH:
if (lEvent == SHCNE_FREESPACE)
{
DWORD dwItem = 0;
int idDrive = PathGetDriveNumber((LPCTSTR)dwItem1);
if (idDrive != -1)
dwItem = (1 << idDrive);
if (dwItem2)
{
idDrive = PathGetDriveNumber((LPCTSTR)dwItem2);
if (idDrive != -1)
dwItem |= (1 << idDrive);
}
dwItem1 = (LPCVOID)ULongToPtr( dwItem );
if (dwItem1)
goto DoDWORD;
goto Cleanup;
}
else
{
if (dwItem1)
{
pidl = pidlFree = SHSimpleIDListFromPath((LPCTSTR)dwItem1);
if (!pidl)
goto Cleanup;
if (dwItem2)
{
pidlExtra = pidlExtraFree = SHSimpleIDListFromPath((LPCTSTR)dwItem2);
if (!pidlExtra)
goto Cleanup;
}
}
}
break;
case SHCNF_PRINTER:
if (dwItem1)
{
TraceMsg(TF_SHELLCHANGENOTIFY, "SHChangeNotify: SHCNF_PRINTER %s", (LPTSTR)dwItem1);
if (FAILED(ParsePrinterName((LPCTSTR)dwItem1, &pidlFree)))
{
goto Cleanup;
}
pidl = pidlFree;
if (dwItem2)
{
if (FAILED(ParsePrinterName((LPCTSTR)dwItem2, &pidlExtraFree)))
{
goto Cleanup;
}
pidlExtra = pidlExtraFree;
}
}
break;
case SHCNF_PRINTJOB:
if (dwItem1)
{
#ifdef DEBUG
switch (lEvent)
{
case SHCNE_CREATE:
TraceMsg(TF_SHELLCHANGENOTIFY, "SHChangeNotify: SHCNE_CREATE SHCNF_PRINTJOB %s", (LPTSTR)dwItem1);
break;
case SHCNE_DELETE:
TraceMsg(TF_SHELLCHANGENOTIFY, "SHChangeNotify: SHCNE_DELETE SHCNF_PRINTJOB %s", (LPTSTR)dwItem1);
break;
case SHCNE_UPDATEITEM:
TraceMsg(TF_SHELLCHANGENOTIFY, "SHChangeNotify: SHCNE_UPDATEITEM SHCNF_PRINTJOB %s", (LPTSTR)dwItem1);
break;
default:
TraceMsg(TF_SHELLCHANGENOTIFY, "SHChangeNotify: SHCNE_? SHCNF_PRINTJOB %s", (LPTSTR)dwItem1);
break;
}
#endif
pidl = pidlFree = Printjob_GetPidl((LPCTSTR)dwItem1, (LPSHCNF_PRINTJOB_DATA)dwItem2);
if (!pidl)
goto Cleanup;
}
else
{
// Caller goofed.
goto Cleanup;
}
break;
case SHCNF_DWORD:
DoDWORD:
ASSERT(lEvent & SHCNE_GLOBALEVENTS);
dwidl.cb = sizeof(dwidl) - sizeof(dwidl.cbZero);
dwidl.dwItem1 = PtrToUlong(dwItem1);
dwidl.dwItem2 = PtrToUlong(dwItem2);
dwidl.cbZero = 0;
pidl = (LPCITEMIDLIST)&dwidl;
pidlExtra = NULL;
break;
case 0:
if (lEvent == SHCNE_FREESPACE) {
// convert this to paths.
FreeSpacePidlToPath((LPCITEMIDLIST)dwItem1, (LPCITEMIDLIST)dwItem2);
goto Cleanup;
}
pidl = (LPCITEMIDLIST)dwItem1;
pidlExtra = (LPCITEMIDLIST)dwItem2;
break;
default:
TraceMsg(TF_ERROR, "SHChangeNotify: Unrecognized uFlags 0x%X", uFlags);
return;
}
if (lEvent && !(lEvent & SHCNE_ASSOCCHANGED) && !pidl)
{
// Caller goofed. SHChangeNotifyTransmit & clients assume pidl is
// non-NULL if lEvent is non-zero (except in the SHCNE_ASSOCCHANGED case),
// and they will crash if we try to send this bogus event. So throw out
// this event and rip.
RIP(FALSE);
goto Cleanup;
}
SHChangeNotifyTransmit(lEvent, uFlags, pidl, pidlExtra, dwEventTime);
Cleanup:
if (pidlFree)
ILFree(pidlFree);
if (pidlExtraFree)
ILFree(pidlExtraFree);
}
// SHChangeNotifySuspendResume
//
// Suspends or resumes filesystem notifications on a path. If bRecursive
// is set, disable/enables them for all child paths as well.
STDAPI_(BOOL) SHChangeNotifySuspendResume(BOOL bSuspend,
LPITEMIDLIST pidlSuspend,
BOOL bRecursive,
DWORD dwReserved)
{
BOOL fRet = FALSE;
HWND hwndSCN = _SCNGetWindow(TRUE, FALSE);
if (hwndSCN)
{
HANDLE hChange;
DWORD dwProcId;
UINT uiFlags = bSuspend ? SCNSUSPEND_SUSPEND : 0;
if (bRecursive)
uiFlags |= SCNSUSPEND_RECURSIVE;
GetWindowThreadProcessId(hwndSCN, &dwProcId);
// overloading the structure semantics here a little bit.
// our two flags
hChange = SHChangeNotification_Create(0, uiFlags, pidlSuspend, NULL, dwProcId, 0);
if (hChange)
{
// Transmit to SCN
fRet = (BOOL)SendMessage(hwndSCN, SCNM_SUSPENDRESUME, (WPARAM)hChange, (LPARAM)dwProcId);
SHChangeNotification_Destroy(hChange, dwProcId);
}
}
return fRet;
}
STDAPI_(void) SHChangeNotifyTerminate(BOOL bLastTerm, BOOL bProcessShutdown)
{
if (g_pscn)
{
PostThreadMessage(GetWindowThreadProcessId(g_hwndSCN, NULL), SCNM_TERMINATE, 0, 0);
}
}
// this deregisters anything that this window might have been registered in
STDAPI_(void) SHChangeNotifyDeregisterWindow(HWND hwnd)
{
HWND hwndSCN = _SCNGetWindow(TRUE, FALSE);
if (hwndSCN)
{
SendMessage(hwndSCN, SCNM_DEREGISTERWINDOW, (WPARAM)hwnd, 0);
}
}
//--------------------------------------------------------------------------
// We changed the way that the SHChangeNotifyRegister function worked, so
// to prevent people from calling the old function, we stub it out here.
// The change we made would have broken everbody because we changed the
// lparam and wparam for the notification messages which are sent to the
// registered window.
//
STDAPI_(ULONG) NTSHChangeNotifyRegister(HWND hwnd,
int fSources, LONG fEvents,
UINT wMsg, int cEntries,
SHChangeNotifyEntry *pfsne)
{
return SHChangeNotifyRegister(hwnd, fSources | SHCNRF_NewDelivery , fEvents, wMsg, cEntries, pfsne);
}
STDAPI_(BOOL) NTSHChangeNotifyDeregister(ULONG ulID)
{
return SHChangeNotifyDeregister(ulID);
}
// NOTE: There is a copy of these functions in shdocvw util.cpp for browser only mode supprt.
// NOTE: functionality changes should also be reflected there.
STDAPI_(void) SHUpdateImageA( LPCSTR pszHashItem, int iIndex, UINT uFlags, int iImageIndex )
{
WCHAR szWHash[MAX_PATH];
SHAnsiToUnicode(pszHashItem, szWHash, ARRAYSIZE(szWHash));
SHUpdateImageW(szWHash, iIndex, uFlags, iImageIndex);
}
STDAPI_(void) SHUpdateImageW( LPCWSTR pszHashItem, int iIndex, UINT uFlags, int iImageIndex )
{
SHChangeUpdateImageIDList rgPidl;
SHChangeDWORDAsIDList rgDWord;
int cLen = MAX_PATH - (lstrlenW( pszHashItem ) + 1);
cLen *= sizeof( WCHAR );
if ( cLen < 0 )
{
cLen = 0;
}
// make sure we send a valid index
if ( iImageIndex == -1 )
{
iImageIndex = II_DOCUMENT;
}
rgPidl.dwProcessID = GetCurrentProcessId();
rgPidl.iIconIndex = iIndex;
rgPidl.iCurIndex = iImageIndex;
rgPidl.uFlags = uFlags;
StrCpyNW(rgPidl.szName, pszHashItem, ARRAYSIZE(rgPidl.szName));
rgPidl.cb = (USHORT)(sizeof( rgPidl ) - cLen);
_ILNext( (LPITEMIDLIST) &rgPidl )->mkid.cb = 0;
rgDWord.cb = sizeof( rgDWord) - sizeof(USHORT);
rgDWord.dwItem1 = iImageIndex;
rgDWord.dwItem2 = 0;
rgDWord.cbZero = 0;
// pump it as an extended event
SHChangeNotify(SHCNE_UPDATEIMAGE, SHCNF_IDLIST, &rgDWord, &rgPidl);
}
// REVIEW: pretty poor implementation of handling updateimage, requiring the caller
// to handle the pidl case instead of passing both pidls down here.
//
STDAPI_(int) SHHandleUpdateImage( LPCITEMIDLIST pidlExtra )
{
SHChangeUpdateImageIDList * pUs = (SHChangeUpdateImageIDList*) pidlExtra;
if ( !pUs )
{
return -1;
}
// if in the same process, or an old style notification
if ( pUs->dwProcessID == GetCurrentProcessId())
{
return *(int UNALIGNED *)((BYTE *)&pUs->iCurIndex);
}
else
{
WCHAR szBuffer[MAX_PATH];
int iIconIndex = *(int UNALIGNED *)((BYTE *)&pUs->iIconIndex);
UINT uFlags = *(UINT UNALIGNED *)((BYTE *)&pUs->uFlags);
ualstrcpynW(szBuffer, pUs->szName, ARRAYSIZE(szBuffer));
// we are in a different process, look up the hash in our index to get the right one...
return SHLookupIconIndexW( szBuffer, iIconIndex, uFlags );
}
}
//
// NOTE: these are OLD APIs, new clients should use new APIs
//
// REVIEW: BobDay - SHChangeNotifyUpdateEntryList doesn't appear to be
// called by anybody and since we've change the notification message
// structure, anybody who calls it needs to be identified and fixed.
//
BOOL WINAPI SHChangeNotifyUpdateEntryList(ULONG ulID, int iUpdateType,
int cEntries, SHChangeNotifyEntry *pfsne)
{
ASSERT(FALSE);
return FALSE;
}
void SHChangeNotifyReceive(LONG lEvent, UINT uFlags, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlExtra)
{
ASSERT(FALSE);
}
BOOL WINAPI SHChangeRegistrationReceive(HANDLE hChangeRegistration, DWORD dwProcId)
{
ASSERT(FALSE);
return FALSE;
}