1195 lines
33 KiB
C++
1195 lines
33 KiB
C++
// 10/12/99 scotthan created
|
|
|
|
#include "shellprv.h"
|
|
#include "filtgrep.h"
|
|
#include <ntquery.h>
|
|
#include <filterr.h>
|
|
|
|
|
|
class CGrepTokens // maintains an index of unicode and ansi grep tokens.
|
|
{
|
|
public:
|
|
STDMETHODIMP Initialize(UINT nCodepage, LPCWSTR pwszMatch, LPCWSTR pwszExclude, BOOL bCaseSensitive);
|
|
STDMETHODIMP_(void) Reset();
|
|
STDMETHODIMP_(BOOL) GrepW(LPCWSTR pwszText);
|
|
STDMETHODIMP_(BOOL) GrepA(LPCSTR pwszText);
|
|
|
|
STDMETHODIMP GetCodePage(UINT* pnCodepage) const;
|
|
STDMETHODIMP GetMatchTokens(OUT LPWSTR pszTokens, UINT cchTokens) const;
|
|
STDMETHODIMP GetExcludeTokens(OUT LPWSTR pszTokens, UINT cchTokens) const;
|
|
|
|
private:
|
|
UINT _nCodepage;
|
|
LPWSTR _pszMatchW, _pszExcludeW; // raw strings, unicode
|
|
LPSTR _pszMatchA, _pszExcludeA; // raw strings, ansi
|
|
|
|
LPCWSTR *_rgpszMatchW, *_rgpszExcludeW; // token index, unicode
|
|
LPCSTR *_rgpszMatchA, *_rgpszExcludeA; // token index, ansi
|
|
|
|
LONG _cMatch, _cExclude; // token counts
|
|
|
|
LPWSTR (__stdcall * _pfnStrStrW)(LPCWSTR, LPCWSTR);
|
|
LPSTR (__stdcall * _pfnStrStrA)(LPCSTR, LPCSTR);
|
|
|
|
public:
|
|
// Ctor, Dtor
|
|
CGrepTokens()
|
|
: _nCodepage(0), _cMatch(0), _cExclude(0), _pfnStrStrW(StrStrIW), _pfnStrStrA(StrStrIA),
|
|
_pszMatchW(NULL), _pszExcludeW(NULL), _rgpszMatchW(NULL), _rgpszExcludeW(NULL),
|
|
_pszMatchA(NULL), _pszExcludeA(NULL), _rgpszMatchA(NULL), _rgpszExcludeA(NULL) {}
|
|
~CGrepTokens() { Reset(); }
|
|
|
|
};
|
|
|
|
|
|
class CGrepBuffer // auxilliary class: per-thread grep buffer
|
|
{
|
|
public:
|
|
CGrepBuffer(ULONG dwThreadID) : _dwThreadID(dwThreadID), _pszBuf(NULL), _cchBuf(0) {}
|
|
virtual ~CGrepBuffer() {delete [] _pszBuf;}
|
|
|
|
STDMETHODIMP Alloc(ULONG cch);
|
|
STDMETHODIMP_(BOOL) IsThread(ULONG dwThread) const {return dwThread == _dwThreadID;}
|
|
STDMETHODIMP_(LPWSTR) Buffer() { return _pszBuf; }
|
|
|
|
#define DEFAULT_GREPBUFFERSIZE 0x00FF // +1 = 1 page.
|
|
|
|
private:
|
|
LPWSTR _pszBuf;
|
|
ULONG _cchBuf;
|
|
ULONG _dwThreadID;
|
|
};
|
|
|
|
|
|
// Makes a heap copy of a widechar string
|
|
LPWSTR _AllocAndCopyString(LPCWSTR pszSrc, UINT cch = -1)
|
|
{
|
|
if (pszSrc)
|
|
{
|
|
if ((int)cch < 0) // must cast to "int" since cch is a UINT
|
|
cch = lstrlenW(pszSrc);
|
|
LPWSTR pszRet = new WCHAR[cch + 1];
|
|
if (pszRet)
|
|
{
|
|
CopyMemory(pszRet, pszSrc, sizeof(*pszSrc) * cch);
|
|
pszRet[cch] = 0;
|
|
return pszRet;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// Makes an ansi copy of a widechar string
|
|
LPSTR _AllocAndCopyAnsiString(UINT nCodepage, LPCWSTR pszSrc, UINT cch = -1)
|
|
{
|
|
if (pszSrc)
|
|
{
|
|
if ((int)cch < 0) // must cast to "int" since cch is a UINT
|
|
cch = lstrlenW(pszSrc);
|
|
int cchBuf = WideCharToMultiByte(nCodepage, 0, pszSrc, cch, NULL, 0, NULL, NULL);
|
|
LPSTR pszRet = new CHAR[cchBuf+1];
|
|
if (pszRet)
|
|
{
|
|
int cchRet = WideCharToMultiByte(nCodepage, 0, pszSrc, cch, pszRet, cchBuf, NULL, NULL);
|
|
pszRet[cchRet] = 0;
|
|
return pszRet;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// CGrepBuffer impl
|
|
|
|
|
|
|
|
STDMETHODIMP CGrepBuffer::Alloc(ULONG cch)
|
|
{
|
|
LPWSTR pszBuf = NULL;
|
|
if (cch)
|
|
{
|
|
if (_pszBuf && _cchBuf >= cch)
|
|
return S_OK;
|
|
|
|
pszBuf = new WCHAR[cch+1];
|
|
if (NULL == pszBuf)
|
|
return E_OUTOFMEMORY;
|
|
|
|
*pszBuf = 0;
|
|
}
|
|
|
|
delete [] _pszBuf;
|
|
_pszBuf = pszBuf;
|
|
_cchBuf = cch;
|
|
|
|
return _pszBuf != NULL ? S_OK : S_FALSE ;
|
|
}
|
|
|
|
|
|
// CGrepTokens impl
|
|
|
|
|
|
|
|
// Counts the number of characters in a string containing NULL-delimited tokens ("foo\0bloke\0TheEnd\0\0")
|
|
LONG _GetTokenListLength(LPCWSTR pszList, LONG* pcTokens = NULL)
|
|
{
|
|
LONG cchRet = 0;
|
|
if (pcTokens) *pcTokens = 0;
|
|
|
|
if (pszList && *pszList)
|
|
{
|
|
LPCWSTR pszToken, pszPrev;
|
|
int i = 0;
|
|
|
|
for (pszToken = pszPrev = pszList;
|
|
pszToken && *pszToken;)
|
|
{
|
|
if (pcTokens)
|
|
(*pcTokens)++;
|
|
|
|
pszToken += lstrlenW(pszToken) + 1,
|
|
cchRet += (DWORD)(pszToken - pszPrev) ;
|
|
pszPrev = pszToken;
|
|
}
|
|
}
|
|
|
|
return cchRet;
|
|
}
|
|
|
|
|
|
|
|
// wide version: Counts and/or indexes NULL-delimited string tokens ("foo\0bloke\0TheEnd\0\0")
|
|
LONG _IndexTokensW(LPCWSTR pszList, LPCWSTR* prgszTokens = NULL)
|
|
{
|
|
LONG cRet = 0;
|
|
if (pszList && *pszList)
|
|
{
|
|
LPCWSTR psz = pszList;
|
|
int i = 0;
|
|
for (; psz && *psz; psz += (lstrlenW(psz) + 1), i++)
|
|
{
|
|
if (prgszTokens)
|
|
prgszTokens[i] = psz;
|
|
cRet++;
|
|
}
|
|
}
|
|
return cRet;
|
|
}
|
|
|
|
|
|
// ansi version: Counts and/or indexes NULL-delimited string tokens ("foo\0bloke\0TheEnd\0\0")
|
|
LONG _IndexTokensA(LPCSTR pszList, LPCSTR* prgszTokens = NULL)
|
|
{
|
|
LONG cRet = 0;
|
|
if (pszList && *pszList)
|
|
{
|
|
LPCSTR psz = pszList;
|
|
int i = 0;
|
|
for (; psz && *psz; psz += (lstrlenA(psz) + 1), i++)
|
|
{
|
|
if (prgszTokens)
|
|
prgszTokens[i] = psz;
|
|
cRet++;
|
|
}
|
|
}
|
|
return cRet;
|
|
}
|
|
|
|
|
|
// wide version: Allocates a string token index and indexes a string of NULL-delimited tokens.
|
|
STDMETHODIMP _AllocAndIndexTokensW(LONG cTokens, LPCWSTR pszList, LPCWSTR** pprgszTokens)
|
|
{
|
|
if (cTokens)
|
|
{
|
|
if (NULL == (*pprgszTokens = new LPCWSTR[cTokens]))
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (cTokens != _IndexTokensW(pszList, *pprgszTokens))
|
|
{
|
|
delete [] (*pprgszTokens);
|
|
*pprgszTokens = NULL;
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// ansi version: Allocates a string token index and indexes a string of NULL-delimited tokens.
|
|
STDMETHODIMP _AllocAndIndexTokensA(LONG cTokens, LPCSTR pszList, LPCSTR** pprgszTokens)
|
|
{
|
|
if (cTokens)
|
|
{
|
|
if (NULL == (*pprgszTokens = new LPCSTR[cTokens]))
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (cTokens != _IndexTokensA(pszList, *pprgszTokens))
|
|
{
|
|
delete [] (*pprgszTokens);
|
|
*pprgszTokens = NULL;
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
// Frees unicode and ansi token lists and corresponding indices.
|
|
void _FreeUniAnsiTokenList(
|
|
OUT LPWSTR* ppszListW,
|
|
OUT LPSTR* ppszListA,
|
|
OUT LPCWSTR** pprgTokensW,
|
|
OUT LPCSTR** pprgTokensA)
|
|
{
|
|
delete [] *ppszListW; *ppszListW = NULL;
|
|
delete [] *ppszListA; *ppszListA = NULL;
|
|
delete [] *pprgTokensW; *pprgTokensW = NULL;
|
|
delete [] *pprgTokensA; *pprgTokensA = NULL;
|
|
}
|
|
|
|
|
|
// Allocates unicode and ansi token lists and corresponding indices.
|
|
STDMETHODIMP _AllocUniAnsiTokenList(
|
|
UINT nCodepage,
|
|
LPCWSTR pszList,
|
|
OUT LPWSTR* ppszListW,
|
|
OUT LPSTR* ppszListA,
|
|
OUT LONG* pcTokens,
|
|
OUT LPCWSTR** pprgTokensW,
|
|
OUT LPCSTR** pprgTokensA)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
LONG cTokens = 0;
|
|
UINT cch = _GetTokenListLength(pszList, &cTokens);
|
|
|
|
*ppszListW = NULL;
|
|
*ppszListA = NULL;
|
|
*pprgTokensW = NULL;
|
|
*pprgTokensA = NULL;
|
|
*pcTokens = 0;
|
|
|
|
if (cTokens)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
if (NULL == (*ppszListW = _AllocAndCopyString(pszList, cch)))
|
|
goto failure_exit;
|
|
|
|
if (NULL == (*ppszListA = _AllocAndCopyAnsiString(nCodepage, pszList, cch)))
|
|
goto failure_exit;
|
|
|
|
if (FAILED((hr = _AllocAndIndexTokensW(cTokens, *ppszListW, pprgTokensW))))
|
|
goto failure_exit;
|
|
|
|
if (FAILED((hr = _AllocAndIndexTokensA(cTokens, *ppszListA, pprgTokensA))))
|
|
goto failure_exit;
|
|
|
|
*pcTokens = cTokens;
|
|
hr = S_OK;
|
|
}
|
|
return hr;
|
|
|
|
failure_exit:
|
|
_FreeUniAnsiTokenList(ppszListW, ppszListA, pprgTokensW, pprgTokensA);
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CGrepTokens::Initialize(UINT nCodepage, LPCWSTR pszMatch, LPCWSTR pszExclude, BOOL bCaseSensitive)
|
|
{
|
|
HRESULT hr = E_INVALIDARG;
|
|
Reset();
|
|
|
|
BOOL bMatchString = (pszMatch && *pszMatch);
|
|
BOOL bExcludeString = (pszExclude && *pszExclude);
|
|
|
|
if (!(bMatchString || bExcludeString))
|
|
return E_INVALIDARG;
|
|
|
|
_nCodepage = nCodepage;
|
|
|
|
if (bCaseSensitive)
|
|
{
|
|
_pfnStrStrW = StrStrW;
|
|
_pfnStrStrA = StrStrA;
|
|
}
|
|
else
|
|
{
|
|
_pfnStrStrW = StrStrIW;
|
|
_pfnStrStrA = StrStrIA;
|
|
}
|
|
|
|
if (bMatchString)
|
|
{
|
|
if (FAILED((hr = _AllocUniAnsiTokenList(nCodepage, pszMatch,
|
|
&_pszMatchW, &_pszMatchA, &_cMatch, &_rgpszMatchW, &_rgpszMatchA))))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
if (bExcludeString)
|
|
{
|
|
if (FAILED((hr = _AllocUniAnsiTokenList(nCodepage, pszExclude,
|
|
&_pszExcludeW, &_pszExcludeA, &_cExclude, &_rgpszExcludeW, &_rgpszExcludeA))))
|
|
{
|
|
return hr;
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CGrepTokens::GetCodePage(UINT* pnCodepage) const
|
|
{
|
|
HRESULT hr = _nCodepage ? S_OK : S_FALSE;
|
|
if (pnCodepage)
|
|
*pnCodepage = _nCodepage;
|
|
return hr;
|
|
}
|
|
|
|
// S_OK we have some match tokens, S_FALSE otherwise
|
|
|
|
STDMETHODIMP CGrepTokens::GetMatchTokens(OUT LPWSTR pszMatch, UINT cchMatch) const
|
|
{
|
|
HRESULT hr = (_pszMatchW && *_pszMatchW) ? S_OK : S_FALSE;
|
|
if (pszMatch)
|
|
lstrcpynW(pszMatch, _pszMatchW ? _pszMatchW : L"", cchMatch);
|
|
return hr;
|
|
}
|
|
|
|
// S_OK we have some exclude tokens, S_FALSE otherwise
|
|
|
|
STDMETHODIMP CGrepTokens::GetExcludeTokens(OUT LPWSTR pszExclude, UINT cchExclude) const
|
|
{
|
|
HRESULT hr = (_pszExcludeW && *_pszExcludeW) ? S_OK : S_FALSE;
|
|
if (pszExclude)
|
|
lstrcpynW(pszExclude, _pszExcludeW ? _pszExcludeW : L"", cchExclude);
|
|
return hr;
|
|
}
|
|
|
|
void CGrepTokens::Reset()
|
|
{
|
|
_FreeUniAnsiTokenList(&_pszMatchW, &_pszMatchA, &_rgpszMatchW, &_rgpszMatchA);
|
|
_FreeUniAnsiTokenList(&_pszExcludeW, &_pszExcludeA, &_rgpszExcludeW, &_rgpszExcludeA);
|
|
_cMatch = _cExclude = 0;
|
|
_nCodepage = 0;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(BOOL) CGrepTokens::GrepW(LPCWSTR pszText)
|
|
{
|
|
BOOL bMatch = FALSE;
|
|
if (pszText)
|
|
{
|
|
BOOL bExclude = FALSE;
|
|
|
|
for (int i = 0; i < _cMatch; i++)
|
|
{
|
|
if (_pfnStrStrW(pszText, _rgpszMatchW[i]))
|
|
{
|
|
bMatch = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < _cExclude; i++)
|
|
{
|
|
if (_pfnStrStrW(pszText, _rgpszExcludeW[i]))
|
|
{
|
|
bExclude = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (_cMatch && _cExclude)
|
|
return bMatch || !_cExclude;
|
|
if (_cExclude)
|
|
return !bExclude;
|
|
}
|
|
return bMatch;
|
|
}
|
|
|
|
STDMETHODIMP_(BOOL) CGrepTokens::GrepA(LPCSTR pszText)
|
|
{
|
|
BOOL bMatch = FALSE;
|
|
if (pszText)
|
|
{
|
|
BOOL bExclude = FALSE;
|
|
for (int i = 0; i < _cMatch; i++)
|
|
{
|
|
if (_pfnStrStrA(pszText, _rgpszMatchA[i]))
|
|
{
|
|
bMatch = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < _cExclude; i++)
|
|
{
|
|
if (_pfnStrStrA(pszText, _rgpszExcludeA[i]))
|
|
{
|
|
bExclude = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (_cMatch && _cExclude)
|
|
return bMatch || !_cExclude;
|
|
if (_cExclude)
|
|
return !bExclude;
|
|
}
|
|
return bMatch;
|
|
}
|
|
|
|
inline STDMETHODIMP_(BOOL) _IsEqualAttribute(const FULLPROPSPEC& fps, REFFMTID fmtid, PROPID propid)
|
|
{
|
|
return IsEqualGUID(fmtid, fps.guidPropSet) &&
|
|
PRSPEC_PROPID == fps.psProperty.ulKind &&
|
|
propid == fps.psProperty.propid;
|
|
}
|
|
|
|
|
|
STDMETHODIMP_(BOOL) _PropVariantGrep(PROPVARIANT* pvar, CGrepTokens* pTokens)
|
|
{
|
|
BOOL bRet = FALSE;
|
|
|
|
switch(pvar->vt)
|
|
{
|
|
case VT_LPWSTR:
|
|
bRet = pTokens->GrepW(pvar->pwszVal);
|
|
break;
|
|
|
|
case VT_BSTR:
|
|
bRet = pTokens->GrepW(pvar->bstrVal);
|
|
break;
|
|
|
|
case VT_LPSTR:
|
|
bRet = pTokens->GrepA(pvar->pszVal);
|
|
break;
|
|
|
|
case VT_VECTOR|VT_LPWSTR:
|
|
{
|
|
for (UINT i = 0; !bRet && i < pvar->calpwstr.cElems; i++)
|
|
bRet = pTokens->GrepW(pvar->calpwstr.pElems[i]);
|
|
break;
|
|
}
|
|
|
|
case VT_VECTOR|VT_BSTR:
|
|
{
|
|
for (UINT i = 0; !bRet && i < pvar->cabstr.cElems; i++)
|
|
bRet = pTokens->GrepW(pvar->cabstr.pElems[i]);
|
|
break;
|
|
}
|
|
|
|
case VT_VECTOR|VT_LPSTR:
|
|
{
|
|
for (UINT i = 0; !bRet && i < pvar->calpstr.cElems; i++)
|
|
bRet = pTokens->GrepA(pvar->calpstr.pElems[i]);
|
|
break;
|
|
}
|
|
|
|
case VT_VECTOR|VT_VARIANT:
|
|
{
|
|
for (UINT i = 0; !bRet && i < pvar->capropvar.cElems; i++)
|
|
bRet = _PropVariantGrep(pvar->capropvar.pElems + i, pTokens);
|
|
break;
|
|
}
|
|
|
|
case VT_BSTR|VT_ARRAY:
|
|
{
|
|
// Only grep 1-dimensional arrays.
|
|
UINT cDims = SafeArrayGetDim(pvar->parray);
|
|
if (cDims == 1)
|
|
{
|
|
LONG lBound, uBound;
|
|
if (SUCCEEDED(SafeArrayGetLBound(pvar->parray, 1, &lBound)) &&
|
|
SUCCEEDED(SafeArrayGetUBound(pvar->parray, 1, &uBound)) &&
|
|
uBound > lBound)
|
|
{
|
|
BSTR *rgpbstr;
|
|
if (SUCCEEDED(SafeArrayAccessData(pvar->parray, (void **)&rgpbstr)))
|
|
{
|
|
for (int i = 0; !bRet && i <= (uBound - lBound); i++)
|
|
{
|
|
bRet = pTokens->GrepW(rgpbstr[i]);
|
|
}
|
|
SafeArrayUnaccessData(pvar->parray);
|
|
}
|
|
}
|
|
}
|
|
else if (cDims > 1)
|
|
{
|
|
ASSERT(FALSE); // we didn't expect > 1 dimension on bstr arrays!
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
// Retrieves grep restriction settings
|
|
STDMETHODIMP_(BOOL) _FetchRestrictionSettings(LPCWSTR pwszVal, LPWSTR* ppwszSettings, BOOL bRefresh)
|
|
{
|
|
ASSERT(ppwszSettings);
|
|
|
|
if (bRefresh)
|
|
{
|
|
delete [] *ppwszSettings;
|
|
*ppwszSettings = NULL;
|
|
}
|
|
|
|
if (NULL == *ppwszSettings)
|
|
{
|
|
HKEY hkeyPolicy = NULL;
|
|
if (RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Search\\ExcludedFileTypes", 0,
|
|
KEY_READ, &hkeyPolicy) == ERROR_SUCCESS)
|
|
{
|
|
DWORD dwType, cbData = 0;
|
|
if (RegQueryValueExW(hkeyPolicy, pwszVal, NULL, &dwType, NULL, &cbData) == ERROR_SUCCESS &&
|
|
REG_MULTI_SZ == dwType)
|
|
{
|
|
if ((*ppwszSettings = new WCHAR[(cbData/sizeof(WCHAR))+ 1]) != NULL)
|
|
{
|
|
if (RegQueryValueExW(hkeyPolicy, pwszVal, NULL,
|
|
&dwType, (LPBYTE)*ppwszSettings, &cbData) != ERROR_SUCCESS)
|
|
{
|
|
*ppwszSettings = 0;
|
|
}
|
|
}
|
|
}
|
|
RegCloseKey(hkeyPolicy);
|
|
}
|
|
|
|
if (NULL == *ppwszSettings) // we found no restriction key or value.
|
|
{
|
|
if ((*ppwszSettings = new WCHAR[1]))
|
|
**ppwszSettings = 0;
|
|
}
|
|
}
|
|
return *ppwszSettings != NULL;
|
|
}
|
|
|
|
|
|
// Scans restriction entries for a match against the specified filename extension
|
|
STDMETHODIMP_(BOOL) _ScanRestrictionSettings(LPCWSTR pwszSettings, LPCWSTR pwszExt)
|
|
{
|
|
ASSERT(pwszSettings);
|
|
ASSERT(pwszExt);
|
|
|
|
for (LPCWSTR psz = pwszSettings; *psz; psz += (lstrlenW(psz) + 1))
|
|
{
|
|
if (0 == StrCmpIW(psz, pwszExt))
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
CFilterGrep::CFilterGrep()
|
|
: _hdpaGrepBuffers(NULL),
|
|
_pTokens(NULL),
|
|
_dwFlags(0),
|
|
_pwszContentRestricted(NULL),
|
|
_pwszPropertiesRestricted(NULL)
|
|
{
|
|
InitializeCriticalSection(&_critsec);
|
|
}
|
|
|
|
CFilterGrep::~CFilterGrep()
|
|
{
|
|
_ClearGrepBuffers();
|
|
delete [] _pwszContentRestricted;
|
|
delete [] _pwszPropertiesRestricted;
|
|
delete _pTokens;
|
|
DeleteCriticalSection(&_critsec);
|
|
}
|
|
|
|
|
|
STDMETHODIMP CFilterGrep::Initialize(UINT nCodepage, LPCWSTR pszMatch, LPCWSTR pszExclude, DWORD dwFlags)
|
|
{
|
|
Reset();
|
|
|
|
if ((0 == (dwFlags & (FGIF_BLANKETGREP|FGIF_GREPFILENAME))) ||
|
|
!((pszMatch && *pszMatch) || (pszExclude && *pszExclude)))
|
|
return E_INVALIDARG;
|
|
|
|
if (!(_pTokens || (_pTokens = new CGrepTokens) != NULL))
|
|
return E_OUTOFMEMORY;
|
|
|
|
_dwFlags = dwFlags;
|
|
|
|
return _pTokens->Initialize(nCodepage, pszMatch, pszExclude, BOOLIFY(dwFlags & FGIF_CASESENSITIVE));
|
|
}
|
|
|
|
|
|
STDMETHODIMP CFilterGrep::Reset()
|
|
{
|
|
if (_pTokens)
|
|
_pTokens->Reset();
|
|
_dwFlags = 0;
|
|
return S_OK;
|
|
}
|
|
|
|
// converts non critical errors into S_FALSE, other return as FAILED(hr)
|
|
HRESULT _MapFilterCriticalError(HRESULT hr)
|
|
{
|
|
switch (hr)
|
|
{
|
|
case FILTER_E_END_OF_CHUNKS:
|
|
case FILTER_E_NO_MORE_TEXT:
|
|
case FILTER_E_NO_MORE_VALUES:
|
|
case FILTER_W_MONIKER_CLIPPED:
|
|
case FILTER_E_NO_TEXT:
|
|
case FILTER_E_NO_VALUES:
|
|
case FILTER_E_EMBEDDING_UNAVAILABLE:
|
|
case FILTER_E_LINK_UNAVAILABLE:
|
|
hr = S_FALSE;
|
|
break;
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// returns:
|
|
// S_OK match
|
|
// S_FALSE did not match
|
|
|
|
STDMETHODIMP CFilterGrep::Grep(IShellFolder *psf, LPCITEMIDLIST pidl, LPCTSTR pszName)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
BOOL bHit = FALSE;
|
|
ULONG ulFlags = IFILTER_FLAGS_OLE_PROPERTIES; // default to try to use pss
|
|
ULONG dwThread = GetCurrentThreadId();
|
|
|
|
if (NULL == _pTokens)
|
|
return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
|
|
|
|
if (_IsRestrictedFileType(pszName))
|
|
return S_FALSE;
|
|
|
|
// Grep the filename.
|
|
if ((_dwFlags & FGIF_GREPFILENAME) && _pTokens->GrepW(pszName))
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
IFilter *pFilter;
|
|
if (SUCCEEDED(psf->BindToStorage(pidl, NULL, IID_PPV_ARG(IFilter, &pFilter))))
|
|
{
|
|
__try
|
|
{
|
|
hr = pFilter->Init(IFILTER_INIT_CANON_PARAGRAPHS |
|
|
IFILTER_INIT_CANON_HYPHENS |
|
|
IFILTER_INIT_CANON_SPACES |
|
|
IFILTER_INIT_APPLY_INDEX_ATTRIBUTES |
|
|
IFILTER_INIT_INDEXING_ONLY,
|
|
0, 0, &ulFlags);
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
hr = E_ABORT;
|
|
}
|
|
|
|
while (!bHit && (S_OK == hr))
|
|
{
|
|
STAT_CHUNK stat;
|
|
|
|
__try
|
|
{
|
|
hr = pFilter->GetChunk(&stat);
|
|
while ((S_OK == hr) && (0 == (stat.flags & (CHUNK_TEXT | CHUNK_VALUE))))
|
|
{
|
|
TraceMsg(TF_WARNING, "CFilterGrep::Grep encountered bad/unknown type for chunk; skipping.");
|
|
hr = pFilter->GetChunk(&stat);
|
|
}
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
hr = E_ABORT;
|
|
}
|
|
|
|
hr = _MapFilterCriticalError(hr); // convert filter errors into S_FALSE
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
ULONG grfDescriminate = (_dwFlags & FGIF_BLANKETGREP);
|
|
|
|
if (FGIF_BLANKETGREP == grfDescriminate ||
|
|
(_IsEqualAttribute(stat.attribute, FMTID_Storage, PID_STG_CONTENTS) ?
|
|
FGIF_GREPPROPERTIES == grfDescriminate : FGIF_GREPCONTENT == grfDescriminate))
|
|
{
|
|
if (((stat.flags & CHUNK_VALUE) && S_OK == _GrepValue(pFilter, &stat)) ||
|
|
((stat.flags & CHUNK_TEXT) && S_OK == _GrepText(pFilter, &stat, dwThread)))
|
|
{
|
|
bHit = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
pFilter->Release();
|
|
}
|
|
|
|
// Grep OLE/NFF properties if appropriate
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (!bHit && (ulFlags & IFILTER_FLAGS_OLE_PROPERTIES) && (_dwFlags & FGIF_BLANKETGREP))
|
|
{
|
|
IPropertySetStorage *pps;
|
|
if (SUCCEEDED(psf->BindToStorage(pidl, NULL, IID_PPV_ARG(IPropertySetStorage, &pps))))
|
|
{
|
|
hr = _GrepProperties(pps);
|
|
bHit = (S_OK == hr);
|
|
pps->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
hr = bHit ? S_OK : S_FALSE;
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CFilterGrep::_GrepValue(IFilter* pFilter, STAT_CHUNK* pstat)
|
|
{
|
|
PROPVARIANT* pvar = NULL;
|
|
HRESULT hr;
|
|
|
|
__try
|
|
{
|
|
hr = pFilter->GetValue(&pvar);
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
hr = E_ABORT;
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _PropVariantGrep(pvar, _pTokens) ? S_OK : S_FALSE;
|
|
PropVariantClear(pvar);
|
|
CoTaskMemFree(pvar);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// Greps OLE/NFF properties.
|
|
STDMETHODIMP CFilterGrep::_GrepProperties(IPropertySetStorage *pss)
|
|
{
|
|
BOOL bHit = FALSE;
|
|
|
|
IEnumSTATPROPSETSTG* pEnumSet;
|
|
|
|
if (SUCCEEDED(pss->Enum(&pEnumSet)))
|
|
{
|
|
STATPROPSETSTG statSet[8];
|
|
DWORD cSets = 0;
|
|
while (!bHit &&
|
|
SUCCEEDED(pEnumSet->Next(ARRAYSIZE(statSet), statSet, &cSets)) && cSets)
|
|
{
|
|
for (UINT i = 0; !bHit && i < cSets; i++)
|
|
{
|
|
IPropertyStorage *pstg;
|
|
if (SUCCEEDED(pss->Open(statSet[i].fmtid, STGM_READ | STGM_DIRECT | STGM_SHARE_EXCLUSIVE, &pstg)))
|
|
{
|
|
bHit = (S_OK == _GrepEnumPropStg(pstg));
|
|
pstg->Release();
|
|
}
|
|
}
|
|
}
|
|
pEnumSet->Release();
|
|
}
|
|
|
|
return bHit ? S_OK : S_FALSE;
|
|
}
|
|
|
|
#define PROPGREPBUFSIZE 16
|
|
|
|
// Reads and greps a block of properties described by a
|
|
// caller-supplied array of PROPSPECs.
|
|
STDMETHODIMP CFilterGrep::_GrepPropStg(IPropertyStorage *pstg, ULONG cspec, PROPSPEC rgspec[])
|
|
{
|
|
PROPVARIANT rgvar[PROPGREPBUFSIZE] = {0}, // stack buffer
|
|
*prgvar = rgvar;
|
|
BOOL bHit = FALSE;
|
|
|
|
if (cspec > ARRAYSIZE(rgvar)) // stack buffer large enough?
|
|
{
|
|
if (NULL == (prgvar = new PROPVARIANT[cspec]))
|
|
return E_OUTOFMEMORY;
|
|
ZeroMemory(prgvar, sizeof(PROPVARIANT) * cspec);
|
|
}
|
|
|
|
// Read properties:
|
|
|
|
HRESULT hr = pstg->ReadMultiple(cspec, rgspec, prgvar);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
for (UINT i = 0; i < cspec; i++)
|
|
{
|
|
if (!bHit)
|
|
bHit = _PropVariantGrep(prgvar + i, _pTokens);
|
|
PropVariantClear(rgvar + i);
|
|
}
|
|
}
|
|
|
|
if (prgvar != rgvar)
|
|
delete [] prgvar;
|
|
|
|
if (SUCCEEDED(hr))
|
|
return bHit ? S_OK : S_FALSE;
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Enumerates and greps all properties in a property set
|
|
STDMETHODIMP CFilterGrep::_GrepEnumPropStg(IPropertyStorage* pstg)
|
|
{
|
|
BOOL bHit = FALSE;
|
|
IEnumSTATPROPSTG* pEnumStg;
|
|
if (SUCCEEDED(pstg->Enum(&pEnumStg)))
|
|
{
|
|
STATPROPSTG statProp[PROPGREPBUFSIZE];
|
|
DWORD cProps;
|
|
|
|
while (!bHit &&
|
|
SUCCEEDED(pEnumStg->Next(ARRAYSIZE(statProp), statProp, &cProps)) && cProps)
|
|
{
|
|
PROPSPEC rgspec[PROPGREPBUFSIZE] = {0};
|
|
for (UINT i = 0; i < cProps; i++)
|
|
{
|
|
rgspec[i].ulKind = PRSPEC_PROPID;
|
|
rgspec[i].propid = statProp[i].propid;
|
|
CoTaskMemFree(statProp[i].lpwstrName);
|
|
}
|
|
|
|
bHit = (S_OK == _GrepPropStg(pstg, cProps, rgspec));
|
|
}
|
|
|
|
pEnumStg->Release();
|
|
}
|
|
|
|
return bHit ? S_OK : S_FALSE;
|
|
}
|
|
|
|
|
|
// Reports whether the indicated unicode character is a
|
|
// word-breaking character.
|
|
inline BOOL _IsWordBreakCharW(IN LPWSTR pszBuf, IN ULONG ich)
|
|
{
|
|
WORD wChar;
|
|
return GetStringTypeW(CT_CTYPE1, pszBuf + ich, 1, &wChar)
|
|
&& (wChar & (C1_SPACE|C1_PUNCT|C1_CNTRL|C1_BLANK));
|
|
}
|
|
|
|
|
|
// Finds the last word-breaking character.
|
|
LPWSTR _FindLastWordBreakW(IN LPWSTR pszBuf, IN ULONG cch)
|
|
{
|
|
while(--cch)
|
|
{
|
|
if (_IsWordBreakCharW(pszBuf, cch))
|
|
return pszBuf + cch;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// {c1243ca0-bf96-11cd-b579-08002b30bfeb}
|
|
const CLSID CLSID_PlainTextFilter = {0xc1243ca0, 0xbf96, 0x11cd, {0xb5, 0x79, 0x08, 0x00, 0x2b, 0x30, 0xbf, 0xeb}};
|
|
|
|
STDMETHODIMP CFilterGrep::_GrepText(IFilter* pFilter, STAT_CHUNK* pstat, DWORD dwThreadID)
|
|
{
|
|
ASSERT(pstat);
|
|
|
|
LPWSTR pszBuf = NULL;
|
|
ULONG cchBuf = pstat->cwcLenSource ?
|
|
pstat->cwcLenSource : DEFAULT_GREPBUFFERSIZE;
|
|
|
|
HRESULT hr = _GetThreadGrepBuffer(dwThreadID, cchBuf, &pszBuf);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPWSTR pszFetch = pszBuf,
|
|
pszTail = NULL;
|
|
ULONG cchFetch = cchBuf,
|
|
cchTail = 0;
|
|
|
|
// Fetch first block of text
|
|
|
|
__try
|
|
{
|
|
hr = pFilter->GetText(&cchFetch, pszFetch);
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
hr = E_ABORT;
|
|
}
|
|
|
|
CLSID clsid = {0};
|
|
IUnknown_GetClassID(pFilter, &clsid); // to workaround a bug in the text filter
|
|
|
|
while (SUCCEEDED(hr) && cchFetch)
|
|
{
|
|
ASSERT((cchFetch + cchTail) <= cchBuf);
|
|
|
|
pszBuf[cchFetch + cchTail] = 0; // don't trust filter to zero-terminate buffer.
|
|
|
|
// When you get the FILTER_S_LAST_TEXT, that's it, you'll get no more text, so treat the tail part as part of the text
|
|
if (hr == FILTER_S_LAST_TEXT)
|
|
{
|
|
pszTail = NULL;
|
|
cchTail = 0;
|
|
}
|
|
else if (CLSID_PlainTextFilter == clsid)
|
|
{
|
|
// CLSID_PlainText filter always returns S_OK, instead of FILTER_S_LAST_TEXT, this forces us to scan
|
|
// the entire chunk now, AND (see below) to pass it off as a tail for scanning next chunk too.
|
|
// pszTail and cchTail are set below.
|
|
}
|
|
else
|
|
{
|
|
pszTail = _FindLastWordBreakW(pszBuf, cchFetch + cchTail);
|
|
if (pszTail)
|
|
{
|
|
// Break on word boundary and leave remainder (tail) for next iteration
|
|
*pszTail = TEXT('\0');
|
|
pszTail++;
|
|
cchTail = lstrlenW(pszTail);
|
|
}
|
|
else
|
|
{
|
|
// Wow, big block, with no word break, search its entirety.
|
|
// REVIEW: cross chunk items won't be found
|
|
pszTail = NULL;
|
|
cchTail = 0;
|
|
}
|
|
}
|
|
|
|
// do the string scan
|
|
if (_pTokens->GrepW(pszBuf))
|
|
{
|
|
*pszBuf = 0;
|
|
return S_OK;
|
|
}
|
|
else if (FILTER_S_LAST_TEXT == hr)
|
|
{
|
|
*pszBuf = 0;
|
|
return S_FALSE;
|
|
}
|
|
|
|
// prepare for next fetch...
|
|
|
|
// If it is the plaintext filter, grab the tail anyway, even though we've tested it already
|
|
// WinSE 25867
|
|
|
|
if (CLSID_PlainTextFilter == clsid)
|
|
{
|
|
pszTail = _FindLastWordBreakW(pszBuf, cchFetch + cchTail);
|
|
if (pszTail)
|
|
{
|
|
*pszTail = TEXT('\0');
|
|
pszTail++;
|
|
cchTail = lstrlenW(pszTail);
|
|
}
|
|
else
|
|
{
|
|
pszTail = NULL;
|
|
cchTail = 0;
|
|
}
|
|
}
|
|
|
|
*pszBuf = 0;
|
|
pszFetch = pszBuf;
|
|
cchFetch = cchBuf;
|
|
|
|
// If there is a tail to deal with, move it to the front of
|
|
// the buffer and prepare to have the next block of incoming text
|
|
// appended to the tail..
|
|
if (pszTail && cchTail)
|
|
{
|
|
MoveMemory(pszBuf, pszTail, cchTail * sizeof(*pszTail));
|
|
pszBuf[cchTail] = 0;
|
|
pszFetch += cchTail;
|
|
cchFetch -= cchTail;
|
|
}
|
|
|
|
// Fetch next block of text.
|
|
__try
|
|
{
|
|
hr = pFilter->GetText(&cchFetch, pszFetch);
|
|
}
|
|
__except(EXCEPTION_EXECUTE_HANDLER)
|
|
{
|
|
hr = E_ABORT;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr) || FILTER_E_NO_MORE_TEXT == hr || FILTER_E_NO_TEXT == hr)
|
|
return S_FALSE;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// Returns a grep buffer of the requested size for the specified thread.
|
|
STDMETHODIMP CFilterGrep::_GetThreadGrepBuffer(
|
|
DWORD dwThreadID,
|
|
ULONG cchNeed,
|
|
LPWSTR* ppszBuf)
|
|
{
|
|
ASSERT(dwThreadID);
|
|
ASSERT(cchNeed > 0);
|
|
ASSERT(ppszBuf);
|
|
|
|
HRESULT hr = E_FAIL;
|
|
*ppszBuf = NULL;
|
|
|
|
_EnterCritical();
|
|
|
|
if (_hdpaGrepBuffers || (_hdpaGrepBuffers = DPA_Create(4)) != NULL)
|
|
{
|
|
CGrepBuffer *pgb, *pgbCached = NULL;
|
|
|
|
for (int i = 0, cnt = DPA_GetPtrCount(_hdpaGrepBuffers); i < cnt; i++)
|
|
{
|
|
pgb = (CGrepBuffer*)DPA_FastGetPtr(_hdpaGrepBuffers, i);
|
|
if (pgb->IsThread(dwThreadID))
|
|
{
|
|
pgbCached = pgb;
|
|
hr = pgbCached->Alloc(cchNeed);
|
|
if (S_OK == hr)
|
|
*ppszBuf = pgbCached->Buffer();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (NULL == pgbCached) // not cached?
|
|
{
|
|
if ((pgb = new CGrepBuffer(dwThreadID)) != NULL)
|
|
{
|
|
hr = pgb->Alloc(cchNeed);
|
|
if (S_OK == hr)
|
|
{
|
|
*ppszBuf = pgb->Buffer();
|
|
DPA_AppendPtr(_hdpaGrepBuffers, pgb);
|
|
}
|
|
else
|
|
delete pgb;
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
_LeaveCritical();
|
|
return hr;
|
|
}
|
|
|
|
|
|
// Frees grep buffer for the specified thread
|
|
STDMETHODIMP CFilterGrep::_FreeThreadGrepBuffer(DWORD dwThreadID)
|
|
{
|
|
HRESULT hr = S_FALSE;
|
|
_EnterCritical();
|
|
|
|
for (int i = 0, cnt = DPA_GetPtrCount(_hdpaGrepBuffers); i < cnt; i++)
|
|
{
|
|
CGrepBuffer* pgb = (CGrepBuffer*) DPA_FastGetPtr(_hdpaGrepBuffers, i);
|
|
if (pgb->IsThread(dwThreadID))
|
|
{
|
|
DPA_DeletePtr(_hdpaGrepBuffers, i);
|
|
hr = S_OK;
|
|
break;
|
|
}
|
|
}
|
|
|
|
_LeaveCritical();
|
|
return hr;
|
|
}
|
|
|
|
|
|
// Clears grep buffer for all threads
|
|
STDMETHODIMP_(void) CFilterGrep::_ClearGrepBuffers()
|
|
{
|
|
_EnterCritical();
|
|
|
|
if (_hdpaGrepBuffers)
|
|
{
|
|
while(DPA_GetPtrCount(_hdpaGrepBuffers))
|
|
{
|
|
CGrepBuffer* pgb = (CGrepBuffer*)DPA_DeletePtr(_hdpaGrepBuffers, 0);
|
|
delete pgb;
|
|
}
|
|
|
|
DPA_Destroy(_hdpaGrepBuffers);
|
|
_hdpaGrepBuffers = NULL;
|
|
}
|
|
|
|
_LeaveCritical();
|
|
}
|
|
|
|
|
|
//#define _USE_GREP_RESTRICTIONS_ // Check for registered list of excluded files types
|
|
|
|
// Reports whether the file type is restricted from full-text grep.
|
|
STDMETHODIMP_(BOOL) CFilterGrep::_IsRestrictedFileType(LPCWSTR pwszFile)
|
|
{
|
|
#ifdef _USE_GREP_RESTRICTIONS_
|
|
LPCWSTR pwszExt = PathFindExtensionW(pwszFile);
|
|
if (pwszExt && *pwszExt)
|
|
{
|
|
if (_dwFlags & FGIF_GREPCONTENT &&
|
|
_FetchRestrictionSettings(L"Content", &_pwszContentRestricted, FALSE))
|
|
{
|
|
if (_ScanRestrictionSettings(_pwszContentRestricted, pwszExt))
|
|
return TRUE;
|
|
}
|
|
|
|
if (_dwFlags & FGIF_GREPCONTENT &&
|
|
_FetchRestrictionSettings(L"Properties", &_pwszPropertiesRestricted, FALSE))
|
|
{
|
|
if (_ScanRestrictionSettings(_pwszPropertiesRestricted, pwszExt))
|
|
return TRUE;
|
|
}
|
|
}
|
|
#endif
|
|
return FALSE;
|
|
}
|
|
|
|
STDMETHODIMP CFilterGrep::GetMatchTokens(OUT LPWSTR pszTokens, UINT cchTokens) const
|
|
{
|
|
HRESULT hr = _pTokens ? _pTokens->GetMatchTokens(pszTokens, cchTokens) : S_FALSE;
|
|
if (S_OK != hr && pszTokens)
|
|
*pszTokens = 0;
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CFilterGrep::GetExcludeTokens(OUT LPWSTR pszTokens, UINT cchTokens) const
|
|
{
|
|
HRESULT hr = _pTokens ? _pTokens->GetExcludeTokens(pszTokens, cchTokens) : S_FALSE;
|
|
if (S_OK != hr && pszTokens)
|
|
*pszTokens = 0;
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CFilterGrep::GetCodePage(UINT* pnCodepage) const
|
|
{
|
|
HRESULT hr = _pTokens ? _pTokens->GetCodePage(pnCodepage) : S_FALSE;
|
|
if (S_OK != hr && pnCodepage)
|
|
*pnCodepage = 0;
|
|
return hr;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CFilterGrep::GetFlags(DWORD* pdwFlags) const
|
|
{
|
|
if (*pdwFlags)
|
|
*pdwFlags = _dwFlags;
|
|
return S_OK;
|
|
}
|