BYTE* NTOWFv2W(LPWSTR Password, UINT32 PasswordLength, LPWSTR User,
UINT32 UserLength, LPWSTR Domain, UINT32 DomainLength, BYTE* NtHash)
{
BYTE* buffer;
BYTE NtHashV1[16];
if ((!User) || (!Password))
return NULL;
if (!NtHash)
NtHash = (BYTE*) malloc(16);
NTOWFv1W(Password, PasswordLength, NtHashV1);
buffer = (BYTE*) malloc(UserLength + DomainLength);
/* Concatenate(UpperCase(User), Domain) */
CopyMemory(buffer, User, UserLength);
CharUpperBuffW((LPWSTR) buffer, UserLength / 2);
CopyMemory(&buffer[UserLength], Domain, DomainLength);
/* Compute the HMAC-MD5 hash of the above value using the NTLMv1 hash as the key, the result is the NTLMv2 hash */
HMAC(EVP_md5(), (void*) NtHashV1, 16, buffer, UserLength + DomainLength, (void*) NtHash, NULL);
free(buffer);
return NtHash;
}
int test_unicode_uppercasing(BYTE* lower, BYTE* upper)
{
WCHAR* lowerW = NULL;
int lowerLength;
WCHAR* upperW = NULL;
int upperLength;
lowerLength = ConvertToUnicode(CP_UTF8, 0, (LPSTR) lower, -1, &lowerW, 0);
upperLength = ConvertToUnicode(CP_UTF8, 0, (LPSTR) upper, -1, &upperW, 0);
CharUpperBuffW(lowerW, lowerLength);
if (_wcscmp(lowerW, upperW) != 0)
{
printf("Lowercase String:\n");
string_hexdump((BYTE*) lowerW, lowerLength * 2);
printf("Uppercase String:\n");
string_hexdump((BYTE*) upperW, upperLength * 2);
return -1;
}
free(lowerW);
free(upperW);
return 0;
}
BOOL WINAPI GetProcessName(DWORD dwPid, TCHAR* lpBuffer, size_t dwBufsize)
{
HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
PROCESSENTRY32 pe = { sizeof(pe), 0 };
size_t nLen;
if (hSnap == INVALID_HANDLE_VALUE)
return FALSE;
if (!Process32First(hSnap, &pe))
return FALSE;
do
{
try
{
if (dwPid != pe.th32ProcessID)
continue;
StringCbLength(pe.szExeFile, MAX_PATH - 1, &nLen);
CharUpperBuffW(pe.szExeFile, nLen);
StringCbCopy(lpBuffer, dwBufsize, pe.szExeFile);
}
catch (...)
{
CloseHandle(hSnap);
return FALSE;
}
} while (Process32Next(hSnap, &pe));
CloseHandle(hSnap);
return TRUE;
}
void str_wrap_text_uppercase(wchar_t *out, aint maxlen)
{
if (IS_UNICODE_OS())
{
CharUpperBuffW(out, maxlen);
} else
{
blk_copy_fwd(out, to_wstr( to_str(wsptr(out, maxlen)).case_up() ).cstr(), maxlen);
}
}
/* =========================================================================
* Process a single file from the /EXCLUDE: file list, building up a list
* of substrings to avoid copying
* Returns TRUE on any failure
* ========================================================================= */
static BOOL XCOPY_ProcessExcludeFile(WCHAR* filename, WCHAR* endOfName) {
WCHAR endChar = *endOfName;
WCHAR buffer[MAXSTRING];
FILE *inFile = NULL;
const WCHAR readTextMode[] = {'r', 't', 0};
/* Null terminate the filename (temporarily updates the filename hence
parms not const) */
*endOfName = 0x00;
/* Open the file */
inFile = _wfopen(filename, readTextMode);
if (inFile == NULL) {
XCOPY_wprintf(XCOPY_LoadMessage(STRING_OPENFAIL), filename);
*endOfName = endChar;
return TRUE;
}
/* Process line by line */
while (fgetws(buffer, sizeof(buffer)/sizeof(WCHAR), inFile) != NULL) {
EXCLUDELIST *thisEntry;
int length = lstrlenW(buffer);
/* Strip CRLF */
buffer[length-1] = 0x00;
/* If more than CRLF */
if (length > 1) {
thisEntry = HeapAlloc(GetProcessHeap(), 0, sizeof(EXCLUDELIST));
thisEntry->next = excludeList;
excludeList = thisEntry;
thisEntry->name = HeapAlloc(GetProcessHeap(), 0,
(length * sizeof(WCHAR))+1);
lstrcpyW(thisEntry->name, buffer);
CharUpperBuffW(thisEntry->name, length);
WINE_TRACE("Read line : '%s'\n", wine_dbgstr_w(thisEntry->name));
}
}
/* See if EOF or error occurred */
if (!feof(inFile)) {
XCOPY_wprintf(XCOPY_LoadMessage(STRING_READFAIL), filename);
*endOfName = endChar;
fclose(inFile);
return TRUE;
}
/* Revert the input string to original form, and cleanup + return */
*endOfName = endChar;
fclose(inFile);
return FALSE;
}
rktio_char16_t *rktio_recase_utf16(rktio_t *rktio, rktio_bool_t to_up, rktio_char16_t *s1, intptr_t l1, intptr_t *olen)
{
#ifdef MACOS_UNICODE_SUPPORT
CFMutableStringRef mstr;
CFStringRef str;
CFRange rng;
rktio_char16_t *result;
intptr_t len;
str = CFStringCreateWithBytes(NULL, (unsigned char *)s1, (l1 * sizeof(rktio_char16_t)), kCFStringEncodingUnicode, FALSE);
mstr = CFStringCreateMutableCopy(NULL, 0, str);
CFRelease(str);
if (to_up)
CFStringUppercase(mstr, NULL);
else
CFStringLowercase(mstr, NULL);
len = CFStringGetLength(mstr);
result = malloc((len + 1) * sizeof(rktio_char16_t));
rng = CFRangeMake(0, len);
CFStringGetCharacters(mstr, rng, (UniChar *)result);
CFRelease(mstr);
result[len] = 0;
if (olen)
*olen = len;
return result;
#elif defined(RKTIO_SYSTEM_WINDOWS)
rktio_char16_t *result;
result = malloc((l1 + 1) * sizeof(rktio_char16_t));
memcpy(result, s1, l1 * sizeof(rktio_char16_t));
result[l1] = 0;
if (to_up)
CharUpperBuffW((wchar_t *)result, l1);
else
CharLowerBuffW((wchar_t *)result, l1);
if (olen)
*olen = l1;
return result;
#else
return NULL;
#endif
}
// One trailing (or middle) asterisk allowed
bool CompareFileMask(const wchar_t* asFileName, const wchar_t* asMask)
{
if (!asFileName || !*asFileName || !asMask || !*asMask)
return false;
// Any file?
if (*asMask == L'*' && *(asMask+1) == 0)
return true;
int iCmp = -1;
wchar_t sz1[MAX_PATH+1], sz2[MAX_PATH+1];
lstrcpyn(sz1, asFileName, countof(sz1));
size_t nLen1 = lstrlen(sz1);
CharUpperBuffW(sz1, (DWORD)nLen1);
lstrcpyn(sz2, asMask, countof(sz2));
size_t nLen2 = lstrlen(sz2);
CharUpperBuffW(sz2, (DWORD)nLen2);
wchar_t* pszAst = wcschr(sz2, L'*');
if (!pszAst)
{
iCmp = lstrcmp(sz1, sz2);
}
else
{
*pszAst = 0;
size_t nLen = pszAst - sz2;
size_t nRight = lstrlen(pszAst+1);
if (wcsncmp(sz1, sz2, nLen) == 0)
{
if (!nRight)
iCmp = 0;
else if (nLen1 >= (nRight + nLen))
iCmp = lstrcmp(sz1+nLen1-nRight, pszAst+1);
}
}
return (iCmp == 0);
}
static HRESULT WINAPI xmlelem_get_tagName(IXMLElement *iface, BSTR *p)
{
xmlelem *This = impl_from_IXMLElement(iface);
TRACE("(%p, %p)\n", iface, p);
if (!p)
return E_INVALIDARG;
*p = bstr_from_xmlChar(This->node->name);
CharUpperBuffW(*p, SysStringLen(*p));
TRACE("returning %s\n", debugstr_w(*p));
return S_OK;
}
static HRESULT WINAPI xmldoc_get_doctype(IXMLDocument *iface, BSTR *p)
{
xmldoc *This = impl_from_IXMLDocument(iface);
xmlDtd *dtd;
TRACE("(%p, %p)\n", This, p);
if (!p) return E_INVALIDARG;
dtd = xmlGetIntSubset(This->xmldoc);
if (!dtd) return S_FALSE;
*p = bstr_from_xmlChar(dtd->name);
CharUpperBuffW(*p, SysStringLen(*p));
return S_OK;
}
/*
* @implemented
*/
DWORD
WINAPI
CharUpperBuffA(LPSTR str, DWORD len)
{
DWORD lenW;
WCHAR* strW;
if (!str) return 0; /* YES */
lenW = MultiByteToWideChar(CP_ACP, 0, str, len, NULL, 0);
strW = HeapAlloc(GetProcessHeap(), 0, lenW * sizeof(WCHAR));
if (strW) {
MultiByteToWideChar(CP_ACP, 0, str, len, strW, lenW);
CharUpperBuffW(strW, lenW);
len = WideCharToMultiByte(CP_ACP, 0, strW, lenW, str, len, NULL, NULL);
HeapFree(GetProcessHeap(), 0, strW);
return len;
}
return 0;
}
LPWSTR WINAPI CharUpperW(
LPWSTR pwsz)
{
/*
* Early out for NULL string or '\0'
*/
if (pwsz == NULL) {
return pwsz;
}
if (!IS_PTR(pwsz)) {
if (!LCMapStringW(
LOCALE_USER_DEFAULT,
LCMAP_UPPERCASE,
(LPWSTR)&pwsz,
1,
(LPWSTR)&pwsz,
1
)) {
/*
* We don't expect LCMapString to fail! The caller is not expecting
* failure, CharLowerW does not have a failure indicator, so we do
* nothing.
*/
RIPMSG1(RIP_WARNING, "CharUpperW(%#p): LCMapString failed", pwsz);
}
return pwsz;
}
/*
* pwsz is a null-terminated string
*/
CharUpperBuffW(pwsz, wcslen(pwsz)+1);
return pwsz;
}
UnicodeString& UnicodeString::Upper(size_t nStartPos, size_t nLength)
{
Inflate(m_pData->GetSize());
CharUpperBuffW(m_pData->GetData()+nStartPos, nLength==(size_t)-1?(DWORD)(m_pData->GetLength()-nStartPos):(DWORD)nLength);
return *this;
}
/* =========================================================================
XCOPY_DoCopy - Recursive function to copy files based on input parms
of a stem and a spec
This works by using FindFirstFile supplying the source stem and spec.
If results are found, any non-directory ones are processed
Then, if /S or /E is supplied, another search is made just for
directories, and this function is called again for that directory
========================================================================= */
static int XCOPY_DoCopy(WCHAR *srcstem, WCHAR *srcspec,
WCHAR *deststem, WCHAR *destspec,
DWORD flags)
{
WIN32_FIND_DATAW *finddata;
HANDLE h;
BOOL findres = TRUE;
WCHAR *inputpath, *outputpath;
BOOL copiedFile = FALSE;
DWORD destAttribs, srcAttribs;
BOOL skipFile;
int ret = 0;
/* Allocate some working memory on heap to minimize footprint */
finddata = HeapAlloc(GetProcessHeap(), 0, sizeof(WIN32_FIND_DATAW));
inputpath = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
outputpath = HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
/* Build the search info into a single parm */
lstrcpyW(inputpath, srcstem);
lstrcatW(inputpath, srcspec);
/* Search 1 - Look for matching files */
h = FindFirstFileW(inputpath, finddata);
while (h != INVALID_HANDLE_VALUE && findres) {
skipFile = FALSE;
/* Ignore . and .. */
if (lstrcmpW(finddata->cFileName, wchr_dot)==0 ||
lstrcmpW(finddata->cFileName, wchr_dotdot)==0 ||
finddata->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
WINE_TRACE("Skipping directory, . or .. (%s)\n", wine_dbgstr_w(finddata->cFileName));
} else {
/* Get the filename information */
lstrcpyW(copyFrom, srcstem);
if (flags & OPT_SHORTNAME) {
lstrcatW(copyFrom, finddata->cAlternateFileName);
} else {
lstrcatW(copyFrom, finddata->cFileName);
}
lstrcpyW(copyTo, deststem);
if (*destspec == 0x00) {
if (flags & OPT_SHORTNAME) {
lstrcatW(copyTo, finddata->cAlternateFileName);
} else {
lstrcatW(copyTo, finddata->cFileName);
}
} else {
lstrcatW(copyTo, destspec);
}
/* Do the copy */
WINE_TRACE("ACTION: Copy '%s' -> '%s'\n", wine_dbgstr_w(copyFrom),
wine_dbgstr_w(copyTo));
if (!copiedFile && !(flags & OPT_SIMULATE)) XCOPY_CreateDirectory(deststem);
/* See if allowed to copy it */
srcAttribs = GetFileAttributesW(copyFrom);
WINE_TRACE("Source attribs: %d\n", srcAttribs);
if ((srcAttribs & FILE_ATTRIBUTE_HIDDEN) ||
(srcAttribs & FILE_ATTRIBUTE_SYSTEM)) {
if (!(flags & OPT_COPYHIDSYS)) {
skipFile = TRUE;
}
}
if (!(srcAttribs & FILE_ATTRIBUTE_ARCHIVE) &&
(flags & OPT_ARCHIVEONLY)) {
skipFile = TRUE;
}
/* See if file exists */
destAttribs = GetFileAttributesW(copyTo);
WINE_TRACE("Dest attribs: %d\n", srcAttribs);
/* Check date ranges if a destination file already exists */
if (!skipFile && (flags & OPT_DATERANGE) &&
(CompareFileTime(&finddata->ftLastWriteTime, &dateRange) < 0)) {
WINE_TRACE("Skipping file as modified date too old\n");
skipFile = TRUE;
}
/* If just /D supplied, only overwrite if src newer than dest */
if (!skipFile && (flags & OPT_DATENEWER) &&
(destAttribs != INVALID_FILE_ATTRIBUTES)) {
HANDLE h = CreateFileW(copyTo, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL,
NULL);
if (h != INVALID_HANDLE_VALUE) {
FILETIME writeTime;
GetFileTime(h, NULL, NULL, &writeTime);
if (CompareFileTime(&finddata->ftLastWriteTime, &writeTime) <= 0) {
WINE_TRACE("Skipping file as dest newer or same date\n");
skipFile = TRUE;
}
CloseHandle(h);
}
}
/* See if exclude list provided. Note since filenames are case
insensitive, need to uppercase the filename before doing
strstr */
if (!skipFile && (flags & OPT_EXCLUDELIST)) {
EXCLUDELIST *pos = excludeList;
WCHAR copyFromUpper[MAX_PATH];
/* Uppercase source filename */
lstrcpyW(copyFromUpper, copyFrom);
CharUpperBuffW(copyFromUpper, lstrlenW(copyFromUpper));
/* Loop through testing each exclude line */
while (pos) {
if (wcsstr(copyFromUpper, pos->name) != NULL) {
WINE_TRACE("Skipping file as matches exclude '%s'\n",
wine_dbgstr_w(pos->name));
skipFile = TRUE;
pos = NULL;
} else {
pos = pos->next;
}
}
}
/* Prompt each file if necessary */
if (!skipFile && (flags & OPT_SRCPROMPT)) {
DWORD count;
char answer[10];
BOOL answered = FALSE;
WCHAR yesChar[2];
WCHAR noChar[2];
/* Read the Y and N characters from the resource file */
wcscpy(yesChar, XCOPY_LoadMessage(STRING_YES_CHAR));
wcscpy(noChar, XCOPY_LoadMessage(STRING_NO_CHAR));
while (!answered) {
XCOPY_wprintf(XCOPY_LoadMessage(STRING_SRCPROMPT), copyFrom);
ReadFile (GetStdHandle(STD_INPUT_HANDLE), answer, sizeof(answer),
&count, NULL);
answered = TRUE;
if (toupper(answer[0]) == noChar[0])
skipFile = TRUE;
else if (toupper(answer[0]) != yesChar[0])
answered = FALSE;
}
}
if (!skipFile &&
destAttribs != INVALID_FILE_ATTRIBUTES && !(flags & OPT_NOPROMPT)) {
DWORD count;
char answer[10];
BOOL answered = FALSE;
WCHAR yesChar[2];
WCHAR allChar[2];
WCHAR noChar[2];
/* Read the A,Y and N characters from the resource file */
wcscpy(yesChar, XCOPY_LoadMessage(STRING_YES_CHAR));
wcscpy(allChar, XCOPY_LoadMessage(STRING_ALL_CHAR));
wcscpy(noChar, XCOPY_LoadMessage(STRING_NO_CHAR));
while (!answered) {
XCOPY_wprintf(XCOPY_LoadMessage(STRING_OVERWRITE), copyTo);
ReadFile (GetStdHandle(STD_INPUT_HANDLE), answer, sizeof(answer),
&count, NULL);
answered = TRUE;
if (toupper(answer[0]) == allChar[0])
flags |= OPT_NOPROMPT;
else if (toupper(answer[0]) == noChar[0])
skipFile = TRUE;
else if (toupper(answer[0]) != yesChar[0])
answered = FALSE;
}
}
/* See if it has to exist! */
if (destAttribs == INVALID_FILE_ATTRIBUTES && (flags & OPT_MUSTEXIST)) {
skipFile = TRUE;
}
/* Output a status message */
if (!skipFile) {
if (flags & OPT_QUIET) {
/* Skip message */
} else if (flags & OPT_FULL) {
const WCHAR infostr[] = {'%', '1', ' ', '-', '>', ' ',
'%', '2', '\n', 0};
XCOPY_wprintf(infostr, copyFrom, copyTo);
} else {
const WCHAR infostr[] = {'%', '1', '\n', 0};
XCOPY_wprintf(infostr, copyFrom);
}
/* If allowing overwriting of read only files, remove any
write protection */
if ((destAttribs & FILE_ATTRIBUTE_READONLY) &&
(flags & OPT_REPLACEREAD)) {
SetFileAttributesW(copyTo, destAttribs & ~FILE_ATTRIBUTE_READONLY);
}
copiedFile = TRUE;
if (flags & OPT_SIMULATE || flags & OPT_NOCOPY) {
/* Skip copy */
} else if (CopyFileW(copyFrom, copyTo, FALSE) == 0) {
DWORD error = GetLastError();
XCOPY_wprintf(XCOPY_LoadMessage(STRING_COPYFAIL),
copyFrom, copyTo, error);
XCOPY_FailMessage(error);
if (flags & OPT_IGNOREERRORS) {
skipFile = TRUE;
} else {
ret = RC_WRITEERROR;
goto cleanup;
}
}
/* If /M supplied, remove the archive bit after successful copy */
if (!skipFile) {
if ((srcAttribs & FILE_ATTRIBUTE_ARCHIVE) &&
(flags & OPT_REMOVEARCH)) {
SetFileAttributesW(copyFrom, (srcAttribs & ~FILE_ATTRIBUTE_ARCHIVE));
}
filesCopied++;
}
}
}
/* Find next file */
findres = FindNextFileW(h, finddata);
}
FindClose(h);
/* Search 2 - do subdirs */
if (flags & OPT_RECURSIVE) {
lstrcpyW(inputpath, srcstem);
lstrcatW(inputpath, wchr_star);
findres = TRUE;
WINE_TRACE("Processing subdirs with spec: %s\n", wine_dbgstr_w(inputpath));
h = FindFirstFileW(inputpath, finddata);
while (h != INVALID_HANDLE_VALUE && findres) {
/* Only looking for dirs */
if ((finddata->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
(lstrcmpW(finddata->cFileName, wchr_dot) != 0) &&
(lstrcmpW(finddata->cFileName, wchr_dotdot) != 0)) {
WINE_TRACE("Handling subdir: %s\n", wine_dbgstr_w(finddata->cFileName));
/* Make up recursive information */
lstrcpyW(inputpath, srcstem);
lstrcatW(inputpath, finddata->cFileName);
lstrcatW(inputpath, wchr_slash);
lstrcpyW(outputpath, deststem);
if (*destspec == 0x00) {
lstrcatW(outputpath, finddata->cFileName);
/* If /E is supplied, create the directory now */
if ((flags & OPT_EMPTYDIR) &&
!(flags & OPT_SIMULATE))
XCOPY_CreateDirectory(outputpath);
lstrcatW(outputpath, wchr_slash);
}
XCOPY_DoCopy(inputpath, srcspec, outputpath, destspec, flags);
}
/* Find next one */
findres = FindNextFileW(h, finddata);
}
FindClose(h);
}
cleanup:
/* free up memory */
HeapFree(GetProcessHeap(), 0, finddata);
HeapFree(GetProcessHeap(), 0, inputpath);
HeapFree(GetProcessHeap(), 0, outputpath);
return ret;
}
wstring upcase(const wstring& str) {
Buffer<wchar_t> up_str(str.size());
wmemcpy(up_str.data(), str.data(), str.size());
CharUpperBuffW(up_str.data(), static_cast<DWORD>(up_str.size()));
return wstring(up_str.data(), up_str.size());
}
void str_wrap_text_uppercase(wchar_t *out, ZSTRINGS_SIGNED maxlen)
{
CharUpperBuffW(out, maxlen);
}
//-----------------------------------------------------------------------------
// Name: DoesItemMatch
// Object: check if item with index ItemIndex in main dialog list view match the filters
// and if item match, select it
// Parameters :
// in : int ItemIndex : item index of dialog main this->pListview
// out :
// return : TRUE if item match, FALSE else
//-----------------------------------------------------------------------------
BOOL CSearch::DoesItemMatch(int ItemIndex)
{
HEAP_CONTENT* pHeapContent;
// get Heap content
if(!this->pListview->GetItemUserData(ItemIndex,(LPVOID*)(&pHeapContent)))
return FALSE;
if (pHeapContent==0)
return FALSE;
if (IsBadReadPtr(pHeapContent,sizeof(HEAP_CONTENT)))
return FALSE;
if ((pHeapContent->HeapEntry.dwBlockSize==0)||(pHeapContent->pData==NULL))
return FALSE;
if (IsBadReadPtr(pHeapContent->pData,pHeapContent->HeapEntry.dwBlockSize))
return FALSE;
// if hex search
if (this->SearchHex)
{
// search HexData into pHeapContent->pData
return this->FindBufferInBuffer(this->HexData,
this->HexDataSize,
pHeapContent->pData,
pHeapContent->HeapEntry.dwBlockSize
);
}
else
// if text search
{
if (this->SearchAscii)
{
char* pc;
if (this->SearchMatchCase)
{
pc=(char*)pHeapContent->pData;
}
// if insensitive search
else
{
// convert buffer to upper case
pc=new char[pHeapContent->HeapEntry.dwBlockSize+1];
if (!pc)
return FALSE;
pc[pHeapContent->HeapEntry.dwBlockSize]=0;
memcpy(pc,pHeapContent->pData,pHeapContent->HeapEntry.dwBlockSize);
CharUpperBuffA(pc,pHeapContent->HeapEntry.dwBlockSize);
}
// search buffer
if (this->FindBufferInBuffer((PBYTE)this->AsciiSearchContent,
this->AsciiSearchContentSize,
(PBYTE)pc,
pHeapContent->HeapEntry.dwBlockSize
)
)
{
if (!this->SearchMatchCase)
delete pc;
return TRUE;
}
if (!this->SearchMatchCase)
delete pc;
}
if (this->SearchUnicode)
{
wchar_t* pc;
if (this->SearchMatchCase)
{
pc=(wchar_t*)pHeapContent->pData;
}
// if insensitive search
else
{
// convert buffer to upper case
pc=new wchar_t[pHeapContent->HeapEntry.dwBlockSize/sizeof(wchar_t)+1];
if (!pc)
return FALSE;
pc[pHeapContent->HeapEntry.dwBlockSize/sizeof(wchar_t)]=0;
memcpy(pc,pHeapContent->pData,pHeapContent->HeapEntry.dwBlockSize/sizeof(wchar_t));
CharUpperBuffW(pc,pHeapContent->HeapEntry.dwBlockSize/sizeof(wchar_t));
}
// search buffer
if (this->FindBufferInBuffer((PBYTE)this->UnicodeSearchContent,
this->UnicodeSearchContentSize,
(PBYTE)pc,
pHeapContent->HeapEntry.dwBlockSize
)
)
{
if (!this->SearchMatchCase)
delete pc;
return TRUE;
}
if (!this->SearchMatchCase)
delete pc;
}
return FALSE;
}
}
