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; } }