// --- BOOL CAvpFileFindW::FindFile(LPCWSTR pstrName /* = NULL */, DWORD dwUnused /* = 0 */) { Close(); m_pNextInfo = new WIN32_FIND_DATAW; m_bGotLast = FALSE; if (pstrName == NULL) pstrName = L"*.*"; /* if ( (wcslen(pstrName) + 1) > _countof(((WIN32_FIND_DATAW*) m_pNextInfo)->cFileName) ) // Это ошибка, конечно. В этом случае мы все равно ничего не найдем. Но, наверное, нужно выполнять // поиск с переходом в каталог return FALSE; wcscpy(((WIN32_FIND_DATAW*) m_pNextInfo)->cFileName, pstrName); */ #if defined(_UNICODE) m_hContext = ::FindFirstFile(pstrName, (WIN32_FIND_DATAW*) m_pNextInfo); #else if ( g_bUnicodePlatform ) m_hContext = ::FindFirstFileW(pstrName, (WIN32_FIND_DATAW*) m_pNextInfo); else { WIN32_FIND_DATAA rcContext; //::WContext2AContext( (WIN32_FIND_DATAW*) m_pNextInfo, &rcContext ); CAPointer<char> pConverted = ::UnicodeToMbcs( pstrName ); m_hContext = ::FindFirstFileA( pConverted, &rcContext ); ::AContext2WContext( &rcContext, (WIN32_FIND_DATAW*) m_pNextInfo ); } #endif if (m_hContext == INVALID_HANDLE_VALUE) { DWORD dwTemp = ::GetLastError(); Close(); ::SetLastError(dwTemp); return FALSE; } #if 0 // Dont use this technique - \\?\ problem LPWSTR pstrRoot = m_strRoot; LPCWSTR pstr = NULL; #if defined(_UNICODE) pstr = _tfullpath(pstrRoot, pstrName, _countof(m_strRoot)); #else if ( g_bUnicodePlatform ) pstr = _wfullpath(pstrRoot, pstrName, _countof(m_strRoot)); else { CAPointer<char> pConverted = ::UnicodeToMbcs( pstrName ); CHAR strRoot[_MAX_PATH]; LPCSTR pAStr = _fullpath(strRoot, pConverted, _countof(strRoot)); if ( pAStr ) { ::MbcsToUnicode( strRoot, pstrRoot, _countof(m_strRoot) ); pstr = pstrRoot; } } #endif // passed name isn't a valid path but was found by the API if (pstr == NULL) { Close(); ::SetLastError(ERROR_INVALID_NAME); return FALSE; } else { // find the last forward or backward whack LPWSTR pstrBack = wcsrchr(pstrRoot, L'\\'); LPWSTR pstrFront = wcsrchr(pstrRoot, L'/'); if (pstrFront != NULL || pstrBack != NULL) { if (pstrFront == NULL) pstrFront = pstrRoot; if (pstrBack == NULL) pstrBack = pstrRoot; // from the start to the last whack is the root if (pstrFront >= pstrBack) *pstrFront = L'\0'; else *pstrBack = L'\0'; } } #endif return TRUE; }
/* * Helper function for search_path */ static wchar_t* search_path_join_test(const wchar_t* dir, int dir_len, const wchar_t* name, int name_len, const wchar_t* ext, int ext_len, const wchar_t* cwd, int cwd_len) { wchar_t *result, *result_pos; DWORD attrs; if (dir_len >= 1 && (dir[0] == L'/' || dir[0] == L'\\')) { /* It's a full path without drive letter, use cwd's drive letter only */ cwd_len = 2; } else if (dir_len >= 2 && dir[1] == L':' && (dir_len < 3 || (dir[2] != L'/' && dir[2] != L'\\'))) { /* It's a relative path with drive letter (ext.g. D:../some/file) * Replace drive letter in dir by full cwd if it points to the same drive, * otherwise use the dir only. */ if (cwd_len < 2 || _wcsnicmp(cwd, dir, 2) != 0) { cwd_len = 0; } else { dir += 2; dir_len -= 2; } } else if (dir_len > 2 && dir[1] == L':') { /* It's an absolute path with drive letter * Don't use the cwd at all */ cwd_len = 0; } /* Allocate buffer for output */ result = result_pos = (wchar_t*)malloc(sizeof(wchar_t) * (cwd_len + 1 + dir_len + 1 + name_len + 1 + ext_len + 1)); /* Copy cwd */ wcsncpy(result_pos, cwd, cwd_len); result_pos += cwd_len; /* Add a path separator if cwd didn't end with one */ if (cwd_len && wcsrchr(L"\\/:", result_pos[-1]) == NULL) { result_pos[0] = L'\\'; result_pos++; } /* Copy dir */ wcsncpy(result_pos, dir, dir_len); result_pos += dir_len; /* Add a separator if the dir didn't end with one */ if (dir_len && wcsrchr(L"\\/:", result_pos[-1]) == NULL) { result_pos[0] = L'\\'; result_pos++; } /* Copy filename */ wcsncpy(result_pos, name, name_len); result_pos += name_len; /* Copy extension */ if (ext_len) { result_pos[0] = L'.'; result_pos++; wcsncpy(result_pos, ext, ext_len); result_pos += ext_len; } /* Null terminator */ result_pos[0] = L'\0'; attrs = GetFileAttributesW(result); if (attrs != INVALID_FILE_ATTRIBUTES && !(attrs & (FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT))) { return result; } free(result); return NULL; }
BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/) { // --CHANGED by Anton Likhtarov for resource support rs::hInst = hInstance; // --END WSADATA wData; WORD wVersion = MAKEWORD(1,1); if (dwReason == DLL_PROCESS_ATTACH) { if( WSAStartup(wVersion, &wData) ) { return FALSE; } hMlang = LoadLibrary(L"mlang.dll"); fConvertINetMultiByteToUnicode = (HRESULT (__stdcall *)(LPDWORD, DWORD, LPCSTR, LPINT, LPWSTR, LPINT)) GetProcAddress(hMlang, "ConvertINetMultiByteToUnicode"); HKEY hKeyDB, hKeyCP; wchar_t cp_subkey[256], cp_fullpath[256]; if (RegOpenKeyEx(HKEY_CLASSES_ROOT, L"MIME\\DataBase\\Codepage", 0, KEY_READ, &hKeyDB) == ERROR_SUCCESS) { DWORD n_cps; RegQueryInfoKey(hKeyDB,NULL,NULL,NULL,&n_cps,NULL,NULL,NULL,NULL,NULL,NULL,NULL); for (int i = 0; i < n_cps; i++) { DWORD dwSize = sizeof(cp_subkey); RegEnumKeyEx(hKeyDB,i,cp_subkey,&dwSize,NULL,NULL,NULL,NULL); UINT cp = _wtoi(cp_subkey); swprintf(cp_fullpath, L"MIME\\DataBase\\Codepage\\%ls", cp_subkey); if (RegOpenKeyEx(HKEY_CLASSES_ROOT, cp_fullpath, 0, KEY_READ, &hKeyCP) != ERROR_SUCCESS) continue; wstring cp_name; GetStringRegKey(hKeyCP, L"WebCharset", cp_name); if (cp_name.length() == 0) GetStringRegKey(hKeyCP, L"BodyCharset", cp_name); if (cp_name.length() > 0 && cp_name[0] != L'_') { transform(cp_name.begin(), cp_name.end(), cp_name.begin(), ::towlower); CPNames[cp] = cp_name; CPIDs[cp_name] = cp; } } RegCloseKey(hKeyDB); } MudCodePage = GetACP(); InitializeCriticalSection(&secSubstSection); InitializeCriticalSection(&secHotkeys); InitializeCriticalSection(&secStatusSection); //vls-begin// #system InitializeCriticalSection(&secSystemExec); InitializeCriticalSection(&secSystemList); //vls-end// //vls-begin// script files InitializeCriticalSection(&secScriptFiles); InitializeCriticalSection(&secReadingConfig); eventReadingConfig = CreateEvent(NULL, TRUE, FALSE, NULL); eventReadingHasUse = CreateEvent(NULL, TRUE, FALSE, NULL); eventReadingFirst = CreateEvent(NULL, TRUE, FALSE, NULL); //vls-end// eventAllObjectEvent = CreateEvent(NULL, FALSE, FALSE, NULL ); SetEvent(eventAllObjectEvent ); eventMudEmuTextArrives = CreateEvent(NULL, TRUE, FALSE, NULL ); //vls-begin// base dir GetModuleFileName(NULL, szBASE_DIR, MAX_PATH); wchar_t *p = wcsrchr(szBASE_DIR, L'\\'); if (p) *p = '\0'; wcscpy(szSETTINGS_DIR, szBASE_DIR); wcscat(szSETTINGS_DIR, L"\\settings"); //vls-end// _Module.Init(ObjectMap, hInstance, &LIBID_TTCOREEXLib); DisableThreadLibraryCalls(hInstance); hPingThread = CreateThread(NULL, 0, &PingThread, NULL, 0, &dwPingThreadID); strLastCommand[0] = L'\0'; last_line[0] = L'\0'; } else if (dwReason == DLL_PROCESS_DETACH){ //vls-begin// multiple output StopLogging(); //vls-end// //vls-begin// bugfix CloseHandle(eventMudEmuTextArrives); //vls-end// //vls-begin// script files CloseHandle(eventReadingFirst); CloseHandle(eventReadingHasUse); CloseHandle(eventReadingConfig); DeleteCriticalSection(&secReadingConfig); DeleteCriticalSection(&secScriptFiles); //vls-end// //vls-begin// #system systemkill_command(L"all"); DeleteCriticalSection(&secSystemList); DeleteCriticalSection(&secSystemExec); //vls-end// DeleteCriticalSection(&secSubstSection); DeleteCriticalSection(&secHotkeys); DeleteCriticalSection(&secStatusSection); CloseHandle(eventAllObjectEvent); #ifdef _DEBUG_LOG if ( hExLog ) CloseHandle(hExLog); #endif _Module.Term(); } return TRUE; // ok }
//-------------------------------------------------------------------------------------- // Helper function to try to find the location of a media file //-------------------------------------------------------------------------------------- HRESULT FindMediaFileCch( WCHAR* strDestPath, int cchDest, LPCWSTR strFilename ) { bool bFound = false; if( NULL == strFilename || strFilename[0] == 0 || NULL == strDestPath || cchDest < 10 ) return E_INVALIDARG; // Get the exe name, and exe path WCHAR strExePath[MAX_PATH] = {0}; WCHAR strExeName[MAX_PATH] = {0}; WCHAR* strLastSlash = NULL; GetModuleFileName( NULL, strExePath, MAX_PATH ); strExePath[MAX_PATH - 1] = 0; strLastSlash = wcsrchr( strExePath, TEXT( '\\' ) ); if( strLastSlash ) { StringCchCopy( strExeName, MAX_PATH, &strLastSlash[1] ); // Chop the exe name from the exe path *strLastSlash = 0; // Chop the .exe from the exe name strLastSlash = wcsrchr( strExeName, TEXT( '.' ) ); if( strLastSlash ) *strLastSlash = 0; } StringCchCopy( strDestPath, cchDest, strFilename ); if( GetFileAttributes( strDestPath ) != 0xFFFFFFFF ) return S_OK; // Search all parent directories starting at .\ and using strFilename as the leaf name WCHAR strLeafName[MAX_PATH] = {0}; StringCchCopy( strLeafName, MAX_PATH, strFilename ); WCHAR strFullPath[MAX_PATH] = {0}; WCHAR strFullFileName[MAX_PATH] = {0}; WCHAR strSearch[MAX_PATH] = {0}; WCHAR* strFilePart = NULL; GetFullPathName( L".", MAX_PATH, strFullPath, &strFilePart ); if( strFilePart == NULL ) return E_FAIL; while( strFilePart != NULL && *strFilePart != '\0' ) { StringCchPrintf( strFullFileName, MAX_PATH, L"%s\\%s", strFullPath, strLeafName ); if( GetFileAttributes( strFullFileName ) != 0xFFFFFFFF ) { StringCchCopy( strDestPath, cchDest, strFullFileName ); bFound = true; break; } StringCchPrintf( strFullFileName, MAX_PATH, L"%s\\%s\\%s", strFullPath, strExeName, strLeafName ); if( GetFileAttributes( strFullFileName ) != 0xFFFFFFFF ) { StringCchCopy( strDestPath, cchDest, strFullFileName ); bFound = true; break; } StringCchPrintf( strSearch, MAX_PATH, L"%s\\..", strFullPath ); GetFullPathName( strSearch, MAX_PATH, strFullPath, &strFilePart ); } if( bFound ) return S_OK; // On failure, return the file as the path but also return an error code StringCchCopy( strDestPath, cchDest, strFilename ); return HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND ); }
// Resolve - Creates a nicely formatted rendition of the CallStack, including // symbolic information (function names and line numbers) if available. and // saves it for later retrieval. This is almost identical to Callstack::dump above. // // Note: The symbol handler must be initialized prior to calling this // function. // // - showInternalFrames (IN): If true, then all frames in the CallStack will be // dumped. Otherwise, frames internal to the heap will not be dumped. // // Return Value: // // None. // void CallStack::resolve(BOOL showInternalFrames) { if (m_resolved) { // already resolved, no need to do it again // resolving twice may report an incorrect module for the stack frames // if the memory was leaked in a dynamic library that was already unloaded. return; } if (m_status & CALLSTACK_STATUS_INCOMPLETE) { // This call stack appears to be incomplete. Using StackWalk64 may be // more reliable. Report(L" HINT: The following call stack may be incomplete. Setting \"StackWalkMethod\"\n" L" in the vld.ini file to \"safe\" instead of \"fast\" may result in a more\n" L" complete stack trace.\n"); } IMAGEHLP_LINE64 sourceInfo = { 0 }; sourceInfo.SizeOfStruct = sizeof(IMAGEHLP_LINE64); BYTE symbolBuffer [sizeof(SYMBOL_INFO) + MAX_SYMBOL_NAME_SIZE] = { 0 }; WCHAR callingModuleName [MAX_PATH] = L""; WCHAR lowerCaseName [MAX_PATH]; const size_t max_line_length = MAXREPORTLENGTH + 1; m_resolvedCapacity = m_size * max_line_length; m_resolved = new WCHAR[m_resolvedCapacity]; const size_t allocedBytes = m_resolvedCapacity * sizeof(WCHAR); ZeroMemory(m_resolved, allocedBytes); // Iterate through each frame in the call stack. for (UINT32 frame = 0; frame < m_size; frame++) { // Try to get the source file and line number associated with // this program counter address. SIZE_T programCounter = (*this)[frame]; g_symbolLock.Enter(); BOOL foundline = FALSE; DWORD displacement = 0; // It turns out that calls to SymGetLineFromAddrW64 may free the very memory we are scrutinizing here // in this method. If this is the case, m_Resolved will be null after SymGetLineFromAddrW64 returns. // When that happens there is nothing we can do except crash. DbgTrace(L"dbghelp32.dll %i: SymGetLineFromAddrW64\n", GetCurrentThreadId()); foundline = SymGetLineFromAddrW64(g_currentProcess, programCounter, &displacement, &sourceInfo); assert(m_resolved != NULL); if (foundline && !showInternalFrames) { wcscpy_s(lowerCaseName, sourceInfo.FileName); _wcslwr_s(lowerCaseName, wcslen(lowerCaseName) + 1); if (isInternalModule(lowerCaseName)) { // Don't show frames in files internal to the heap. g_symbolLock.Leave(); continue; } } // Initialize structures passed to the symbol handler. SYMBOL_INFO* functionInfo = (SYMBOL_INFO*)&symbolBuffer; functionInfo->SizeOfStruct = sizeof(SYMBOL_INFO); functionInfo->MaxNameLen = MAX_SYMBOL_NAME_LENGTH; // Try to get the name of the function containing this program // counter address. DWORD64 displacement64 = 0; LPWSTR functionName; DbgTrace(L"dbghelp32.dll %i: SymFromAddrW\n", GetCurrentThreadId()); if (SymFromAddrW(g_currentProcess, programCounter, &displacement64, functionInfo)) { functionName = functionInfo->Name; } else { // GetFormattedMessage( GetLastError() ); functionName = L"(Function name unavailable)"; displacement64 = 0; } g_symbolLock.Leave(); HMODULE hCallingModule = GetCallingModule(programCounter); LPWSTR moduleName = L"(Module name unavailable)"; if (hCallingModule && GetModuleFileName(hCallingModule, callingModuleName, _countof(callingModuleName)) > 0) { moduleName = wcsrchr(callingModuleName, L'\\'); if (moduleName == NULL) moduleName = wcsrchr(callingModuleName, L'/'); if (moduleName != NULL) moduleName++; else moduleName = callingModuleName; } // Use static here to increase performance, and avoid heap allocs. Hopefully this won't // prove to be an issue in thread safety. If it does, it will have to be simply non-static. static WCHAR stack_line[max_line_length] = L""; int NumChars = -1; // Display the current stack frame's information. if (foundline) { // Just truncate anything that is too long. if (displacement == 0) NumChars = _snwprintf_s(stack_line, max_line_length, _TRUNCATE, L" %s (%d): %s!%s\n", sourceInfo.FileName, sourceInfo.LineNumber, moduleName, functionName); else NumChars = _snwprintf_s(stack_line, max_line_length, _TRUNCATE, L" %s (%d): %s!%s + 0x%X bytes\n", sourceInfo.FileName, sourceInfo.LineNumber, moduleName, functionName, displacement); } else { if (displacement64 == 0) NumChars = _snwprintf_s(stack_line, max_line_length, _TRUNCATE, L" " ADDRESSFORMAT L" (File and line number not available): %s!%s\n", programCounter, moduleName, functionName); else NumChars = _snwprintf_s(stack_line, max_line_length, _TRUNCATE, L" " ADDRESSFORMAT L" (File and line number not available): %s!%s + 0x%X bytes\n", programCounter, moduleName, functionName, (DWORD)displacement64); } if (NumChars >= 0) { assert(m_resolved != NULL); m_resolvedLength += NumChars; wcsncat_s(m_resolved, m_resolvedCapacity, stack_line, NumChars); } } // end for loop }
Bool CodeSet_Init(const char *icuDataDir) // IN: ICU data file location in Current code page. // Default is used if NULL. { #ifdef NO_ICU /* Nothing required if not using ICU. */ return TRUE; #else // NO_ICU DynBuf dbpath; #ifdef _WIN32 DWORD attribs; utf16_t *modPath = NULL; utf16_t *lastSlash; utf16_t *wpath; HANDLE hFile = INVALID_HANDLE_VALUE; HANDLE hMapping = NULL; void *memMappedData = NULL; #else struct stat finfo; #endif char *path = NULL; Bool ret = FALSE; DynBuf_Init(&dbpath); #ifdef USE_ICU /* * We're using system ICU, which finds its own data. So nothing to * do here. */ dontUseIcu = FALSE; ret = TRUE; goto exit; #endif /* * ********************* WARNING * Must avoid recursive calls into the codeset library here, hence * the idiotic hoop-jumping. DO NOT change any of these calls to * wrapper equivalents or call any other functions that may perform * string conversion. * ********************* WARNING */ #ifdef _WIN32 // { #if vmx86_devel && !defined(TEST_CUSTOM_ICU_DATA_FILE) /* * Devel builds use toolchain directory first. */ { WCHAR icuFilePath[MAX_PATH] = { 0 }; DWORD n = ExpandEnvironmentStringsW(ICU_DATA_FILE_PATH, icuFilePath, ARRAYSIZE(icuFilePath)); if (n > 0 && n < ARRAYSIZE(icuFilePath)) { attribs = GetFileAttributesW(icuFilePath); if ((INVALID_FILE_ATTRIBUTES != attribs) || (attribs & FILE_ATTRIBUTE_DIRECTORY) == 0) { if (!CodeSetOld_Utf16leToCurrent((const char *) icuFilePath, n * sizeof *icuFilePath, &path, NULL)) { goto exit; } goto found; } } } #endif if (icuDataDir) { /* * Data file must be in the specified directory. */ size_t length = strlen(icuDataDir); if (!DynBuf_Append(&dbpath, icuDataDir, length)) { goto exit; } if (length && icuDataDir[length - 1] != DIRSEPC) { if (!DynBuf_Append(&dbpath, DIRSEPS, strlen(DIRSEPS))) { goto exit; } } if (!DynBuf_Append(&dbpath, ICU_DATA_FILE, strlen(ICU_DATA_FILE)) || !DynBuf_Append(&dbpath, "\0", 1)) { goto exit; } /* * Check for file existence. */ attribs = GetFileAttributesA(DynBuf_Get(&dbpath)); if ((INVALID_FILE_ATTRIBUTES == attribs) || (attribs & FILE_ATTRIBUTE_DIRECTORY)) { goto exit; } path = (char *) DynBuf_Detach(&dbpath); } else { /* * Data file must be in the directory of the current module * (i.e. the module that contains CodeSet_Init()). */ HMODULE hModule = W32Util_GetModuleByAddress((void *) CodeSet_Init); if (!hModule) { goto exit; } modPath = CodeSetGetModulePath(hModule); if (!modPath) { goto exit; } lastSlash = wcsrchr(modPath, DIRSEPC_W); if (!lastSlash) { goto exit; } *lastSlash = L'\0'; if (!DynBuf_Append(&dbpath, modPath, wcslen(modPath) * sizeof(utf16_t)) || !DynBuf_Append(&dbpath, DIRSEPS_W, wcslen(DIRSEPS_W) * sizeof(utf16_t)) || !DynBuf_Append(&dbpath, ICU_DATA_FILE_W, wcslen(ICU_DATA_FILE_W) * sizeof(utf16_t)) || !DynBuf_Append(&dbpath, L"\0", 2)) { goto exit; } /* * Since u_setDataDirectory can't handle UTF-16, we would have to * now convert this path to local encoding. But that fails when * the module is in a path containing characters not in the * local encoding (see 282524). So we'll memory-map the file * instead and call udata_setCommonData() below. */ wpath = (utf16_t *) DynBuf_Get(&dbpath); hFile = CreateFileW(wpath, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL); if (INVALID_HANDLE_VALUE == hFile) { goto exit; } hMapping = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL); if (NULL == hMapping) { goto exit; } memMappedData = MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0); if (NULL == memMappedData) { goto exit; } } #else // } _WIN32 { #if vmx86_devel && !defined(TEST_CUSTOM_ICU_DATA_FILE) { char *modPath; char *lastSlash; /* * Devel builds use toolchain directory first. */ if (stat(ICU_DATA_FILE_PATH, &finfo) >= 0 && !S_ISDIR(finfo.st_mode)) { if ((path = strdup(ICU_DATA_FILE_PATH)) == NULL) { goto exit; } goto found; } /* * Then we try module directory, if we can get it. */ modPath = CodeSetGetModulePath(HGMP_PRIVILEGE); if (modPath) { lastSlash = strrchr(modPath, DIRSEPC); if (lastSlash) { *lastSlash = '\0'; if (DynBuf_Append(&dbpath, modPath, strlen(modPath)) && DynBuf_Append(&dbpath, DIRSEPS, strlen(DIRSEPS)) && DynBuf_Append(&dbpath, ICU_DATA_FILE, strlen(ICU_DATA_FILE)) && DynBuf_Append(&dbpath, "\0", 1)) { if ((stat((const char *) DynBuf_Get(&dbpath), &finfo) >= 0) && !S_ISDIR(finfo.st_mode)) { free(modPath); path = DynBuf_Detach(&dbpath); goto found; } else { DynBuf_SetSize(&dbpath, 0); } } } free(modPath); } } #endif // vmx86_devel if (icuDataDir) { /* Use the caller-specified ICU data dir. */ if (!DynBuf_Append(&dbpath, icuDataDir, strlen(icuDataDir))) { goto exit; } } else { /* Use a default ICU data dir. */ # if defined __APPLE__ Location_GetLibrary_Type *Location_GetLibrary = Location_GetLibrary_Addr(); if (Location_GetLibrary) { char *libDir = Location_GetLibrary(); Bool success = libDir && DynBuf_Append(&dbpath, libDir, strlen(libDir)); free(libDir); if (!success) { goto exit; } } else # endif { if (!DynBuf_Append(&dbpath, POSIX_ICU_DIR, strlen(POSIX_ICU_DIR))) { goto exit; } } if (!DynBuf_Append(&dbpath, "/icu", strlen("/icu"))) { goto exit; } } if (!DynBuf_Append(&dbpath, DIRSEPS, strlen(DIRSEPS)) || !DynBuf_Append(&dbpath, ICU_DATA_FILE, strlen(ICU_DATA_FILE)) || !DynBuf_Append(&dbpath, "\0", 1)) { goto exit; } /* * Check for file existence. (DO NOT CHANGE TO 'stat' WRAPPER). */ path = (char *) DynBuf_Detach(&dbpath); if (stat(path, &finfo) < 0 || S_ISDIR(finfo.st_mode)) { goto exit; } #endif // } _WIN32 #if vmx86_devel && !defined(TEST_CUSTOM_ICU_DATA_FILE) found: #endif #ifdef _WIN32 if (memMappedData) { /* * Tell ICU to use this mapped data. */ UErrorCode uerr = U_ZERO_ERROR; ASSERT(memMappedData); udata_setCommonData(memMappedData, &uerr); if (uerr != U_ZERO_ERROR) { UnmapViewOfFile(memMappedData); goto exit; } udata_setAppData(ICU_DATA_ITEM, memMappedData, &uerr); if (uerr != U_ZERO_ERROR) { UnmapViewOfFile(memMappedData); goto exit; } } else { #endif /* * Tell ICU to use this directory. */ u_setDataDirectory(path); #ifdef _WIN32 } #endif dontUseIcu = FALSE; ret = TRUE; exit: if (!ret) { /* * There was an error initing ICU, but if we can fall back on * non-ICU (old CodeSet) then things are OK. */ if (CODESET_CAN_FALLBACK_ON_NON_ICU) { ret = TRUE; dontUseIcu = TRUE; #ifdef _WIN32 OutputDebugStringW(L"CodeSet_Init: no ICU\n"); #endif } } #ifdef _WIN32 free(modPath); if (hMapping) { CloseHandle(hMapping); } if (hFile != INVALID_HANDLE_VALUE) { CloseHandle(hFile); } #endif free(path); DynBuf_Destroy(&dbpath); return ret; #endif }
/*--------------------------------------------------------------------------*/ char *getScilabDirectory(BOOL UnixStyle) { char *SciPathName = NULL; wchar_t* wcSciPathName = NULL; wchar_t ScilabModuleName[MAX_PATH + 1]; wchar_t drive[_MAX_DRIVE]; wchar_t dir[_MAX_DIR]; wchar_t fname[_MAX_FNAME]; wchar_t ext[_MAX_EXT]; wchar_t *DirTmp = NULL; if (!GetModuleFileNameW ((HINSTANCE)GetModuleHandleW(L"core"), (wchar_t*) ScilabModuleName, MAX_PATH)) { return NULL; } os_wsplitpath(ScilabModuleName, drive, dir, fname, ext); if (dir[wcslen(dir) - 1] == L'\\') { dir[wcslen(dir) - 1] = L'\0'; } DirTmp = wcsrchr (dir, L'\\'); if (wcslen(dir) - wcslen(DirTmp) > 0) { dir[wcslen(dir) - wcslen(DirTmp)] = L'\0'; } else { return NULL; } wcSciPathName = (wchar_t*)MALLOC((int)( wcslen(drive) + wcslen(dir) + 5) * sizeof(wchar_t)); if (wcSciPathName) { _wmakepath(wcSciPathName, drive, dir, NULL, NULL); if ( UnixStyle ) { int i = 0; for (i = 0; i < (int)wcslen(wcSciPathName); i++) { if (wcSciPathName[i] == L'\\') { wcSciPathName[i] = L'/'; } } } wcSciPathName[wcslen(wcSciPathName) - 1] = '\0'; SciPathName = wide_string_to_UTF8(wcSciPathName); FREE(wcSciPathName); wcSciPathName = NULL; } if (SciPathName) { setSCI(SciPathName); } return SciPathName; }
void LoadLangDll() { if (g_langid != g_ShellCache.GetLangID() && (g_langTimeout == 0 || g_langTimeout < GetTickCount64())) { g_langid = g_ShellCache.GetLangID(); DWORD langId = g_langid; TCHAR langDll[MAX_PATH*4] = {0}; HINSTANCE hInst = nullptr; TCHAR langdir[MAX_PATH] = {0}; char langdirA[MAX_PATH] = {0}; if (GetModuleFileName(g_hmodThisDll, langdir, _countof(langdir))==0) return; if (GetModuleFileNameA(g_hmodThisDll, langdirA, _countof(langdirA))==0) return; TCHAR* dirpoint = wcsrchr(langdir, L'\\'); char * dirpointA = strrchr(langdirA, '\\'); if (dirpoint) *dirpoint = L'\0'; if (dirpointA) *dirpointA = '\0'; dirpoint = wcsrchr(langdir, L'\\'); dirpointA = strrchr(langdirA, '\\'); if (dirpoint) *dirpoint = L'\0'; if (dirpointA) *dirpointA = '\0'; strcat_s(langdirA, "\\Languages"); BOOL bIsWow = FALSE; IsWow64Process(GetCurrentProcess(), &bIsWow); do { if (bIsWow) swprintf_s(langDll, L"%s\\Languages\\TortoiseProc32%lu.dll", langdir, langId); else swprintf_s(langDll, L"%s\\Languages\\TortoiseProc%lu.dll", langdir, langId); BOOL versionmatch = TRUE; struct TRANSARRAY { WORD wLanguageID; WORD wCharacterSet; }; DWORD dwReserved,dwBufferSize; dwBufferSize = GetFileVersionInfoSize((LPTSTR)langDll,&dwReserved); if (dwBufferSize > 0) { LPVOID pBuffer = (void*) malloc(dwBufferSize); if (pBuffer) { UINT nInfoSize = 0; UINT nFixedLength = 0; LPSTR lpVersion = nullptr; VOID* lpFixedPointer; if (GetFileVersionInfo((LPTSTR)langDll, dwReserved, dwBufferSize, pBuffer)) { // Query the current language if (VerQueryValue( pBuffer, L"\\VarFileInfo\\Translation", &lpFixedPointer, &nFixedLength)) { auto lpTransArray = reinterpret_cast<TRANSARRAY*>(lpFixedPointer); TCHAR strLangProductVersion[MAX_PATH] = { 0 }; swprintf_s(strLangProductVersion, L"\\StringFileInfo\\%04x%04x\\ProductVersion", lpTransArray[0].wLanguageID, lpTransArray[0].wCharacterSet); if (VerQueryValue(pBuffer, (LPTSTR)strLangProductVersion, (LPVOID*)&lpVersion, &nInfoSize)) versionmatch = (wcscmp((LPCTSTR)lpVersion, _T(STRPRODUCTVER)) == 0); } } free(pBuffer); } // if (pBuffer) } // if (dwBufferSize > 0) else versionmatch = FALSE; if (versionmatch) hInst = LoadLibrary(langDll); if (hInst) { if (g_hResInst != g_hmodThisDll) FreeLibrary(g_hResInst); g_hResInst = hInst; } else { DWORD lid = SUBLANGID(langId); lid--; if (lid > 0) langId = MAKELANGID(PRIMARYLANGID(langId), lid); else langId = 0; } } while (!hInst && langId != 0); if (!hInst) { // either the dll for the selected language is not present, or // it is the wrong version. // fall back to English and set a timeout so we don't retry // to load the language dll too often if (g_hResInst != g_hmodThisDll) FreeLibrary(g_hResInst); g_hResInst = g_hmodThisDll; g_langid = 1033; // set a timeout of 10 seconds if (g_ShellCache.GetLangID() != 1033) g_langTimeout = GetTickCount64() + 10000; } else g_langTimeout = 0; } // if (g_langid != g_ShellCache.GetLangID()) }
CNamedHKey::CNamedHKey( BSTR bstrRegFullKeyValueName, SPLITKEYVALUE skv /* =KEYANDVALUE */) : m_skv(skv) { m_hk = m_hkNonRemote = NULL; m_bstrRegFullKeyValueName = bstrRegFullKeyValueName; m_ptszComputername = m_ptszKeyname = m_ptszValuename = NULL; m_lErr = ERROR_SUCCESS; if (bstrRegFullKeyValueName == NULL) { _Cleanup(ERROR_INVALID_DATA); return; } // check for leading "\\computername\" if (bstrRegFullKeyValueName[0] == L'\\' && bstrRegFullKeyValueName[1] == L'\\') { BSTR bstrHKey = wcschr(bstrRegFullKeyValueName + 2, L'\\'); // no '\' terminating computername or zero-length computername? if (bstrHKey == NULL || bstrHKey == bstrRegFullKeyValueName + 2) { _Cleanup(ERROR_INVALID_DATA); return; } m_ptszComputername = TcsNDup(bstrRegFullKeyValueName, bstrHKey - bstrRegFullKeyValueName); if (m_ptszComputername == NULL) { _Cleanup(ERROR_OUTOFMEMORY); return; } bstrRegFullKeyValueName = bstrHKey + 1; } // Parse out the leading HKEY_xxx if ((m_hkNonRemote = _ParseHKeyRoot(bstrRegFullKeyValueName)) == NULL) { _Cleanup(ERROR_INVALID_HANDLE); return; } if (m_skv == KEYONLY) { // do not split into Key\Value pair m_ptszKeyname = TcsNDup(bstrRegFullKeyValueName); m_ptszValuename = NULL; } else if (m_skv == KEYANDVALUE) { // Look for last '\' to split off Valuename BSTR bstrValue = wcsrchr(bstrRegFullKeyValueName, L'\\'); // Have name of form "HKLM\foo"; i.e., only one component? if (bstrValue == NULL) { m_ptszKeyname = TcsNDup(OLESTR("")); m_ptszValuename = TcsNDup(bstrRegFullKeyValueName); } else { m_ptszKeyname = TcsNDup(bstrRegFullKeyValueName, bstrValue - bstrRegFullKeyValueName); m_ptszValuename = TcsNDup(bstrValue + 1); } if (m_ptszValuename == NULL) { _Cleanup(ERROR_OUTOFMEMORY); return; } } else { _Cleanup(ERROR_INVALID_DATA); return; } if (m_ptszKeyname == NULL) { _Cleanup(ERROR_OUTOFMEMORY); return; } // Open the key on a remote registry? if (m_ptszComputername == NULL) { m_hk = m_hkNonRemote; m_hkNonRemote = NULL; } else { m_lErr = ::RegConnectRegistry(m_ptszComputername, m_hkNonRemote, &m_hk); if (m_lErr != ERROR_SUCCESS) _Cleanup(m_lErr); } // At this point, if m_hk == NULL, there's been an error. // Otherwise, m_hk is the key we'll use. // If m_hkNonRemote != NULL, it's one of the predefined // constants, HKEY_CLASSES_ROOT ... HKEY_DYN_DATA // and m_hk refers to a key on a remote registry. // else HKEY_CLASSES_ROOT <= m_hk <= HKEY_DYN_DATA. TRACE(_T("computer = `%s', keyname = `%s'\n") _T("\tvaluename = `%s', hk = %x, hkNonRemote = %x, ") _T("split = %d, err = %x\n"), m_ptszComputername, m_ptszKeyname, m_ptszValuename, (UINT) m_hk, (UINT) m_hkNonRemote, (int) m_skv, m_lErr); }
static HRESULT DeleteEmptyDirectory( __in LEGACY_FILE_TYPE fileType, __in_z LPCWSTR wzPath ) { HRESULT hr = S_OK; LPWSTR sczParentDirectory = NULL; DWORD dwIndex = 0; LPWSTR pwcLastBackslash = NULL; // If it's an individual file and it exists, no point trying to delete any directories for it if (LEGACY_FILE_PLAIN == fileType) { if (FileExistsEx(wzPath, NULL)) { ExitFunction1(hr = S_OK); } } else { // It's a directory, so delete children first hr = DeleteEmptyDirectoryChildren(wzPath); // This code is just an FYI that the directory was not empty and so wasn't deleted. It's not an error, so ignore it. if (FAILED(hr)) { ExitFunction1(hr = S_OK); } ExitOnFailure(hr, "Failed to check for empty directories and delete them at path: %ls", wzPath); } hr = StrAllocString(&sczParentDirectory, wzPath, 0); ExitOnFailure(hr, "Failed to allocate copy of directory"); // Eliminate any trailing backslashes from the directory first, if there are any dwIndex = lstrlenW(sczParentDirectory); if (0 == dwIndex) { hr = E_INVALIDARG; ExitOnFailure(hr, "Unexpected empty parent directory encountered while deleting empty directories"); } --dwIndex; // Start at the last character of the string while (dwIndex > 0 && sczParentDirectory[dwIndex] == L'\\') { sczParentDirectory[dwIndex] = L'\0'; --dwIndex; } if (0 == dwIndex) { hr = E_INVALIDARG; ExitOnFailure(hr, "Parent directory was entirely composed of backslashes!"); } // Now delete any empty parent directories we see as well while (NULL != (pwcLastBackslash = wcsrchr(sczParentDirectory, L'\\'))) { hr = DirEnsureDelete(sczParentDirectory, FALSE, FALSE); if (FAILED(hr)) { LogErrorString(hr, "Failed to check for empty parent directories and delete them at directory: %ls", sczParentDirectory); hr = S_OK; break; } *pwcLastBackslash = L'\0'; } LExit: ReleaseStr(sczParentDirectory); return hr; }
HRESULT ConfigParser::SetOutputFile(const WCHAR* outputFile, const WCHAR* openMode) { // If present, replace the {PID} token with the process ID const WCHAR* pidStr = nullptr; WCHAR buffer[_MAX_PATH]; if ((pidStr = wcsstr(outputFile, L"{PID}")) != nullptr) { size_t pidStartPosition = pidStr - outputFile; WCHAR* pDest = buffer; size_t bufferLen = _MAX_PATH; // Copy the filename before the {PID} token wcsncpy_s(pDest, bufferLen, outputFile, pidStartPosition); pDest += pidStartPosition; bufferLen = bufferLen - pidStartPosition; // Copy the PID _ultow_s(GetCurrentProcessId(), pDest, /*bufferSize=*/_MAX_PATH - pidStartPosition, /*radix=*/10); #pragma prefast(suppress: 26014, "ultow string length is smaller than 256") pDest += wcslen(pDest); bufferLen = bufferLen - wcslen(pDest); // Copy the rest of the string. #pragma prefast(suppress: 26014, "Overwriting pDset's null terminator is intentional since the string being copied is null terminated") wcscpy_s(pDest, bufferLen, outputFile + pidStartPosition + /*length of {PID}*/ 5); outputFile = buffer; } wchar_t fileName[_MAX_PATH]; wchar_t moduleName[_MAX_PATH]; GetModuleFileName(0, moduleName, _MAX_PATH); _wsplitpath_s(moduleName, nullptr, 0, nullptr, 0, fileName, _MAX_PATH, nullptr, 0); if (_wcsicmp(fileName, L"WWAHost") == 0 || _wcsicmp(fileName, L"ByteCodeGenerator") == 0 || _wcsicmp(fileName, L"spartan") == 0 || _wcsicmp(fileName, L"spartan_edge") == 0 || _wcsicmp(fileName, L"MicrosoftEdge") == 0 || _wcsicmp(fileName, L"MicrosoftEdgeCP") == 0) { // we need to output to %temp% directory in wwa. we don't have permission otherwise. if (GetEnvironmentVariable(L"temp", fileName, _MAX_PATH) != 0) { wcscat_s(fileName, _MAX_PATH, L"\\"); const wchar_t * fileNameOnly = wcsrchr(outputFile, L'\\'); // if outputFile is full path we just need filename, discard the path wcscat_s(fileName, _MAX_PATH, fileNameOnly == nullptr ? outputFile : fileNameOnly); } else { AssertMsg(FALSE, "Get temp environment failed"); } outputFile = fileName; } FILE *fp; if ((fp = _wfsopen(outputFile, openMode, _SH_DENYWR)) != nullptr) { Output::SetOutputFile(fp); return S_OK; } AssertMsg(false, "Could not open file for logging output."); return E_FAIL; }
static HRESULT DeleteEmptyRegistryKeys( __in LEGACY_SYNC_PRODUCT_SESSION *pSyncProductSession ) { HRESULT hr = S_OK; const LEGACY_REGISTRY_KEY *rgRegKeys = pSyncProductSession->product.rgRegKeys; const DWORD cRegKeys = pSyncProductSession->product.cRegKeys; DWORD dwIndex = 0; LPWSTR pwcLastBackslash = NULL; LPWSTR sczParentKey = NULL; for (DWORD i = 0; i < cRegKeys; ++i) { hr = DeleteEmptyRegistryKeyChildren(rgRegKeys[i].dwRoot, rgRegKeys[i].sczKey); // This code is just an FYI that the key was not empty and so wasn't deleted. It's not an error, so ignore it. if (HRESULT_FROM_WIN32(ERROR_DIR_NOT_EMPTY) == hr) { hr = S_OK; continue; } ExitOnFailure(hr, "Failed to check for empty keys and delete them at root: %u, subkey: %ls", rgRegKeys[i].dwRoot, rgRegKeys[i].sczKey); hr = StrAllocString(&sczParentKey, rgRegKeys[i].sczKey, 0); ExitOnFailure(hr, "Failed to allocate copy of subkey"); // Eliminate any trailing backslashes from the key first, if there are any dwIndex = lstrlenW(sczParentKey); if (0 == dwIndex) { hr = E_INVALIDARG; ExitOnFailure(hr, "Unexpected empty parent key encountered while deleting empty registry keys"); } --dwIndex; // Start at the last character of the string while (dwIndex > 0 && sczParentKey[dwIndex] == L'\\') { sczParentKey[dwIndex] = L'\0'; --dwIndex; } if (0 == dwIndex) { hr = E_INVALIDARG; ExitOnFailure(hr, "Parent key was entirely composed of backslashes!"); } // Now delete any empty parent keys we see as well while (NULL != (pwcLastBackslash = wcsrchr(sczParentKey, L'\\'))) { hr = RegDelete(ManifestConvertToRootKey(rgRegKeys[i].dwRoot), sczParentKey, REG_KEY_DEFAULT, FALSE); // This code is just an FYI that the key was not empty and so wasn't deleted. It's not an error, so ignore it. if (FAILED(hr)) { LogErrorString(hr, "Failed to check for empty parent keys and delete them at root: %u, subkey: %ls", rgRegKeys[i].dwRoot, sczParentKey); hr = S_OK; break; } *pwcLastBackslash = L'\0'; } } LExit: ReleaseStr(sczParentKey); return hr; }
static NTSTATUS OpenRegistryHandlesFromSymbolicLink(IN PUNICODE_STRING SymbolicLinkName, IN ACCESS_MASK DesiredAccess, IN OPTIONAL PHANDLE GuidKey, IN OPTIONAL PHANDLE DeviceKey, IN OPTIONAL PHANDLE InstanceKey) { OBJECT_ATTRIBUTES ObjectAttributes; WCHAR PathBuffer[MAX_PATH]; UNICODE_STRING BaseKeyU; UNICODE_STRING GuidString, SubKeyName, ReferenceString; PWCHAR StartPosition, EndPosition; HANDLE ClassesKey; PHANDLE GuidKeyRealP, DeviceKeyRealP, InstanceKeyRealP; HANDLE GuidKeyReal, DeviceKeyReal, InstanceKeyReal; NTSTATUS Status; SubKeyName.Buffer = NULL; if (GuidKey != NULL) GuidKeyRealP = GuidKey; else GuidKeyRealP = &GuidKeyReal; if (DeviceKey != NULL) DeviceKeyRealP = DeviceKey; else DeviceKeyRealP = &DeviceKeyReal; if (InstanceKey != NULL) InstanceKeyRealP = InstanceKey; else InstanceKeyRealP = &InstanceKeyReal; *GuidKeyRealP = INVALID_HANDLE_VALUE; *DeviceKeyRealP = INVALID_HANDLE_VALUE; *InstanceKeyRealP = INVALID_HANDLE_VALUE; BaseKeyU.Buffer = PathBuffer; BaseKeyU.Length = 0; BaseKeyU.MaximumLength = MAX_PATH * sizeof(WCHAR); RtlAppendUnicodeToString(&BaseKeyU, BaseKeyString); /* Open the DeviceClasses key */ InitializeObjectAttributes(&ObjectAttributes, &BaseKeyU, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL); Status = ZwOpenKey(&ClassesKey, DesiredAccess | KEY_ENUMERATE_SUB_KEYS, &ObjectAttributes); if (!NT_SUCCESS(Status)) { DPRINT1("Failed to open %wZ\n", &BaseKeyU); goto cleanup; } StartPosition = wcschr(SymbolicLinkName->Buffer, L'{'); EndPosition = wcschr(SymbolicLinkName->Buffer, L'}'); if (!StartPosition || !EndPosition || StartPosition > EndPosition) { DPRINT1("Bad symbolic link: %wZ\n", SymbolicLinkName); return STATUS_INVALID_PARAMETER_1; } GuidString.Buffer = StartPosition; GuidString.MaximumLength = GuidString.Length = (USHORT)((ULONG_PTR)(EndPosition + 1) - (ULONG_PTR)StartPosition); InitializeObjectAttributes(&ObjectAttributes, &GuidString, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, ClassesKey, NULL); Status = ZwOpenKey(GuidKeyRealP, DesiredAccess | KEY_ENUMERATE_SUB_KEYS, &ObjectAttributes); ZwClose(ClassesKey); if (!NT_SUCCESS(Status)) { DPRINT1("Failed to open %wZ%wZ (%x)\n", &BaseKeyU, &GuidString, Status); goto cleanup; } SubKeyName.MaximumLength = SymbolicLinkName->Length + sizeof(WCHAR); SubKeyName.Length = 0; SubKeyName.Buffer = ExAllocatePool(PagedPool, SubKeyName.MaximumLength); if (!SubKeyName.Buffer) { Status = STATUS_INSUFFICIENT_RESOURCES; goto cleanup; } RtlAppendUnicodeStringToString(&SubKeyName, SymbolicLinkName); SubKeyName.Buffer[SubKeyName.Length / sizeof(WCHAR)] = UNICODE_NULL; SubKeyName.Buffer[0] = L'#'; SubKeyName.Buffer[1] = L'#'; SubKeyName.Buffer[2] = L'?'; SubKeyName.Buffer[3] = L'#'; ReferenceString.Buffer = wcsrchr(SubKeyName.Buffer, '\\'); if (ReferenceString.Buffer != NULL) { ReferenceString.Buffer[0] = L'#'; SubKeyName.Length = (USHORT)((ULONG_PTR)(ReferenceString.Buffer) - (ULONG_PTR)SubKeyName.Buffer); ReferenceString.Length = SymbolicLinkName->Length - SubKeyName.Length; } else { RtlInitUnicodeString(&ReferenceString, L"#"); } InitializeObjectAttributes(&ObjectAttributes, &SubKeyName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, *GuidKeyRealP, NULL); Status = ZwOpenKey(DeviceKeyRealP, DesiredAccess | KEY_ENUMERATE_SUB_KEYS, &ObjectAttributes); if (!NT_SUCCESS(Status)) { DPRINT1("Failed to open %wZ%wZ\\%wZ\n", &BaseKeyU, &GuidString, &SubKeyName); goto cleanup; } InitializeObjectAttributes(&ObjectAttributes, &ReferenceString, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, *DeviceKeyRealP, NULL); Status = ZwOpenKey(InstanceKeyRealP, DesiredAccess, &ObjectAttributes); if (!NT_SUCCESS(Status)) { DPRINT1("Failed to open %wZ%wZ\\%wZ%\\%wZ (%x)\n", &BaseKeyU, &GuidString, &SubKeyName, &ReferenceString, Status); goto cleanup; } Status = STATUS_SUCCESS; cleanup: if (SubKeyName.Buffer != NULL) ExFreePool(SubKeyName.Buffer); if (NT_SUCCESS(Status)) { if (!GuidKey) ZwClose(*GuidKeyRealP); if (!DeviceKey) ZwClose(*DeviceKeyRealP); if (!InstanceKey) ZwClose(*InstanceKeyRealP); } else { if (*GuidKeyRealP != INVALID_HANDLE_VALUE) ZwClose(*GuidKeyRealP); if (*DeviceKeyRealP != INVALID_HANDLE_VALUE) ZwClose(*DeviceKeyRealP); if (*InstanceKeyRealP != INVALID_HANDLE_VALUE) ZwClose(*InstanceKeyRealP); } return Status; }
DXResourceHandle CDXShaderManager::CreateResource(void* pShaderDesc, WCHAR* szCustomKey) { DXResourceKey key; DXResourceMapInsertResult insertResult; DXResourceHandle returnValue; DXShaderDesc* pDesc; CDXShader* pShader; pDesc = (DXShaderDesc*)pShaderDesc; pShader = nullptr; // Custom key given? Well and good. But it's better not to provide a // custom key for shaders. if (szCustomKey) { wcscpy_s(key.m_szName, DX_MAX_RESOURCE_KEY_NAME, szCustomKey); } else // No? Process a key name of format %FILE%_%ENTRY%_%PROFILE% { WCHAR szFileName[DX_MAX_FILE_NAME]; WCHAR* pFileName; WCHAR* pDot; // Find the last slash. pFileName = wcsrchr(pDesc->szFileName, '\\'); // If not found, then only the file name is present. if (!pFileName) { pFileName = pDesc->szFileName; } // Copy the file name to a local variable. wcscpy_s(szFileName, DX_MAX_FILE_NAME, pFileName); // Find the extension full stop. pDot = wcsrchr(szFileName, '.'); // We don't need the file extension. if (pDot) { *pDot = 0; } // Format our key name: %FILE%_%ENTRY%_%PROFILE% // So keep file and function names small. wsprintf(key.m_szName, L"%s_%s_%s", szFileName, pDesc->szEntryPoint, pDesc->szShaderLevel); } // Try to insert the shader with the key into the map. insertResult = InsertResource(key, pShader); if (insertResult.second) // New resource inserted? { HRESULT hr = S_OK; // New shader resource on the heap. pShader = new CDXShader(); // Create the resource. NOTE: This does not create the resource // in the graphics memory. It only prepares the resource so that it // can be created anytime using Recreate() method. DX_V(pShader->Create(pShaderDesc)); if (FAILED(hr)) // Failed? { DX_DEBUG_OUTPUT2(L"Failed on a shader: FILE:%s, ENTRY: %s.", pDesc->szFileName, pDesc->szEntryPoint); // Free the memory. DX_SAFE_DELETE(pShader); return returnValue; } // Success! insertResult.first->second = pShader; AddMemoryUsage(pShader->GetSize()); } else // Existing element returned. { pShader = (CDXShader*)insertResult.first->second; } pShader->AddRef(); returnValue.key = key; returnValue.pResource = pShader; return returnValue; }
BOOL CheckThreads ( __in DWORD ProcId ) /*++ Routine Description: Enumerates all threads (or optionally only threads for one process) in the system. It the calls the WCT API on each of them. Arguments: ProcId--Specifies the process ID to analyze. If '0' all processes in the system will be checked. Return Value: TRUE if processes could be checked; FALSE if a general failure occurred. --*/ { DWORD processes[1024]; DWORD numProcesses; DWORD i; // Try to enable the SE_DEBUG_NAME privilege for this process. We // continue even if this fails--we just won't be able to retrieve // wait chains for processes not owned by the current user. if (!GrantDebugPrivilege()) { printf("Couldn't enable debug privilege"); } // Get a list of all processes currently running. if (EnumProcesses(processes, sizeof(processes), &numProcesses) == FALSE) { printf("Couldn't enumerate processes"); return FALSE; } for (i = 0; i < numProcesses / sizeof(DWORD); i++) { HANDLE process; HANDLE snapshot; if (processes[i] == GetCurrentProcessId()) { continue; } // If the caller specified a Process ID, check if we have a match. if (ProcId != 0) { if (processes[i] != ProcId) { continue; } } // Get a handle to this process. process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, processes[i]); if (process) { WCHAR file[MAX_PATH]; printf("Process 0x%x - ", processes[i]); // Retrieve the EXE's name and print it. if (GetProcessImageFileName(process, file, ARRAYSIZE(file)) > 0) { PCWSTR filePart = wcsrchr(file, L'\\'); if (filePart) { filePart++; } else { filePart = file; } printf("%S", filePart); } printf("\n----------------------------------\n"); // Get a snapshot of this process. This allows us to // enumerate its threads. snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, processes[i]); if (snapshot) { THREADENTRY32 thread; thread.dwSize = sizeof(thread); // Walk the thread list and print the wait chain // for each. if (Thread32First(snapshot, &thread)) { do { if (thread.th32OwnerProcessID == processes[i]) { // Open a handle to this specific thread,... HANDLE threadHandle = OpenThread(THREAD_ALL_ACCESS, FALSE, thread.th32ThreadID); if (threadHandle) { // ...check if it is still running,... DWORD exitCode; GetExitCodeThread(threadHandle, &exitCode); if (exitCode == STILL_ACTIVE) { // ...and print its wait chain. PrintWaitChain(thread.th32ThreadID); } CloseHandle(threadHandle); } } } while (Thread32Next(snapshot, &thread)); } CloseHandle(snapshot); } CloseHandle(process); printf("\n"); } } return TRUE; }
static bool InitDbgHelp() { static bool doinit = true; static bool ret = false; if(!doinit) return ret; doinit = false; HMODULE module = NULL; // can't reliably co-exist with dbghelp already being used in the process if(GetModuleHandleA("dbghelp.dll") != NULL) { ret = false; return false; } else { wchar_t path[MAX_PATH] = {0}; GetModuleFileNameW(GetModuleHandleA("renderdoc.dll"), path, MAX_PATH-1); wchar_t *slash = wcsrchr(path, '\\'); if(slash) { *slash = 0; } else { slash = wcsrchr(path, '/'); if(slash == 0) { ret = false; return false; } *slash = 0; } #if defined(WIN64) wcscat_s(path, L"/pdblocate/x64/dbghelp.dll"); #else wcscat_s(path, L"/pdblocate/x86/dbghelp.dll"); #endif module = LoadLibraryW(path); } if(!module) { RDCWARN("Couldn't open dbghelp.dll"); ret = false; return false; } dynSymInitializeW = (PSYMINITIALIZEW)GetProcAddress(module, "SymInitializeW"); dynSymEnumerateModules64W = (PSYMENUMERATEMODULES64W)GetProcAddress(module, "SymEnumerateModulesW64"); dynSymGetModuleInfo64W = (PSYMGETMODULEINFO64W)GetProcAddress(module, "SymGetModuleInfoW64"); if(!dynSymInitializeW || !dynSymEnumerateModules64W || !dynSymGetModuleInfo64W) { RDCERR("Couldn't get some dbghelp function"); ret = false; return ret; } dynSymInitializeW(GetCurrentProcess(), L".", TRUE); HMODULE hModule = NULL; GetModuleHandleEx( GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS|GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, (LPCTSTR)&dllLocator, &hModule); if(hModule != NULL) { MODULEINFO modinfo = { 0 }; BOOL result = GetModuleInformation(GetCurrentProcess(), hModule, &modinfo, sizeof(modinfo)); if(result != FALSE) { renderdocBase = modinfo.lpBaseOfDll; renderdocSize = modinfo.SizeOfImage; } } ret = true; return ret; }
NTSTATUS Log_Rotate() { NTSTATUS Status = STATUS_SUCCESS; HANDLE hFile = NULL; OBJECT_ATTRIBUTES fAttrs; UNICODE_STRING FileName; IO_STATUS_BLOCK StatusBlock = { 0 }; ULONG RotateIndex = 0; FILE_RENAME_INFORMATION *RenameBuffer = NULL; LPCWSTR BaseFileName = LogFileName; ULONG BaseFileNameLength = 0; if (!LogFileName || !LogFile) return STATUS_INVALID_DEVICE_STATE; LPWSTR End1 = wcsrchr(LogFileName, L'\\'), End2 = wcsrchr(LogFileName, L'/'); if ((SIZE_T)End1 > (SIZE_T)End2 > 0) BaseFileName = End1 ? End1 + 1 : LogFileName; else BaseFileName = End2 ? End2 + 1 : LogFileName; BaseFileNameLength = (ULONG)(wcslen(BaseFileName) + 4) * sizeof(WCHAR); ULONG FileNameLength = (ULONG)(wcslen(LogFileName) + 5) * sizeof(WCHAR); RenameBuffer = ExAllocatePoolWithTag(PagedPool, FileNameLength + FIELD_OFFSET(FILE_RENAME_INFORMATION, FileName), LogAllocationTag); if (!RenameBuffer) { Status = STATUS_INSUFFICIENT_RESOURCES; goto Cleanup; } RenameBuffer->FileNameLength = BaseFileNameLength; RenameBuffer->ReplaceIfExists = FALSE; RenameBuffer->RootDirectory = NULL; // Rename already rotated files first Status = StringCbPrintf(RenameBuffer->FileName, FileNameLength, L"%ws.%03d", LogFileName, LogSettings.MaxKeptRotatedFiles); if (!SUCCEEDED(Status)) goto Cleanup; RtlInitUnicodeString(&FileName, RenameBuffer->FileName); InitializeObjectAttributes(&fAttrs, &FileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL); ZwDeleteFile(&fAttrs); for (RotateIndex = LogSettings.MaxKeptRotatedFiles - 1; RotateIndex > 0; RotateIndex--) { Status = StringCbPrintf(RenameBuffer->FileName, FileNameLength, L"%ws.%03d", LogFileName, RotateIndex); if (!SUCCEEDED(Status)) goto Cleanup; RtlInitUnicodeString(&FileName, RenameBuffer->FileName); InitializeObjectAttributes(&fAttrs, &FileName, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, NULL, NULL); Status = ZwOpenFile(&hFile, DELETE, &fAttrs, &StatusBlock, 0, 0); if (!NT_SUCCESS(Status)) continue; Status = StringCbPrintf(RenameBuffer->FileName, FileNameLength, L"%ws.%03d", BaseFileName, RotateIndex + 1); if (!SUCCEEDED(Status)) goto Cleanup; Status = ZwSetInformationFile(hFile, &StatusBlock, RenameBuffer, FileNameLength + FIELD_OFFSET(FILE_RENAME_INFORMATION, FileName), FileRenameInformation); if (!NT_SUCCESS(Status)) goto Cleanup; ZwClose(hFile); hFile = NULL; } // Rename it Status = StringCbPrintf(RenameBuffer->FileName, FileNameLength, L"%ws.%03d", BaseFileName, 1); if (!SUCCEEDED(Status)) goto Cleanup; // Compress Status = Log_CompressFile(LogFile); Status = ZwSetInformationFile(LogFile, &StatusBlock, RenameBuffer, FileNameLength + FIELD_OFFSET(FILE_RENAME_INFORMATION, FileName), FileRenameInformation); if (!NT_SUCCESS(Status)) goto Cleanup; // And start logging into the new file ZwClose(LogFile); LogFile = NULL; Status = Log_StartFileLogging(LogFileName); Cleanup: if (hFile) ZwClose(hFile); if (RenameBuffer) ExFreePoolWithTag(RenameBuffer, LogAllocationTag); return Status; }
VOID GetVersionInfo( BOOL Verbose ) { WCHAR NameBuffer[MAXVERSIONBUFFER]; WCHAR Title1[128]; WCHAR Title2[128]; WCHAR wszPID[MAXVERSIONSTRING]; WCHAR wszPro[MAXVERSIONSTRING]; WCHAR wszSrv[MAXVERSIONSTRING]; WCHAR wszPBuild[MAXVERSIONSTRING]; WCHAR wszEvaluation[MAXVERSIONSTRING]; UNICODE_STRING UserBuildString; UNICODE_STRING UserTypeString; UNICODE_STRING UserCSDString; NTSTATUS Status; RTL_QUERY_REGISTRY_TABLE BaseServerRegistryConfigurationTable[] = { {NULL, RTL_QUERY_REGISTRY_DIRECT, L"CurrentBuildNumber", &UserBuildString, REG_NONE, NULL, 0}, {NULL, RTL_QUERY_REGISTRY_DIRECT, L"CurrentType", &UserTypeString, REG_NONE, NULL, 0}, {NULL, RTL_QUERY_REGISTRY_DIRECT, L"CSDVersion", &UserCSDString, REG_NONE, NULL, 0}, {NULL, 0, NULL, NULL, REG_NONE, NULL, 0} }; UserBuildString.Buffer = &NameBuffer[OFFSET_BLDSTRING]; UserBuildString.Length = 0; UserBuildString.MaximumLength = MAXVERSIONSTRING * sizeof(WCHAR); UserTypeString.Buffer = &NameBuffer[OFFSET_TYPSTRING]; UserTypeString.Length = 0; UserTypeString.MaximumLength = MAXVERSIONSTRING * sizeof(WCHAR); UserCSDString.Buffer = &NameBuffer[OFFSET_CSDSTRING]; UserCSDString.Length = 0; UserCSDString.MaximumLength = MAXVERSIONSTRING * sizeof(WCHAR); Status = RtlQueryRegistryValues(RTL_REGISTRY_WINDOWS_NT, L"", BaseServerRegistryConfigurationTable, NULL, NULL); if (!NT_SUCCESS(Status)) { RIPMSG1(RIP_WARNING, "GetVersionInfo failed with status %x", Status); return; } ServerLoadString( hModuleWin, STR_DTBS_PRODUCTID, wszPID, ARRAY_SIZE(wszPID) ); ServerLoadString( hModuleWin, STR_DTBS_PRODUCTPRO, wszPro, ARRAY_SIZE(wszPro) ); ServerLoadString( hModuleWin, STR_DTBS_PRODUCTSRV, wszSrv, ARRAY_SIZE(wszSrv) ); ServerLoadString( hModuleWin, STR_DTBS_PRODUCTBUILD, wszPBuild, ARRAY_SIZE(wszPBuild) ); /* * Write out Debugging Version message. */ /* * Bug 280256 - joejo * Create new desktop build information strings */ swprintf( wszProductName, wszPID, ((USER_SHARED_DATA->NtProductType == NtProductWinNt) ? wszPro : wszSrv) ); if (gfUnsignedDrivers) { /* This takes precedence */ ServerLoadString( hModuleWin, STR_TESTINGONLY, wszEvaluation, ARRAY_SIZE(wszEvaluation) ); } else if (USER_SHARED_DATA->SystemExpirationDate.QuadPart) { ServerLoadString(hModuleWin, STR_DTBS_EVALUATION, wszEvaluation, ARRAY_SIZE(wszEvaluation)); } else { wszEvaluation[0] = '\0'; } swprintf( wszProductBuild, wszPBuild, wszEvaluation, UserBuildString.Buffer ); if (Verbose) { ServerLoadString( hModuleWin, STR_SAFEMODE_TITLE1, Title1, ARRAY_SIZE(Title1) ); ServerLoadString( hModuleWin, STR_SAFEMODE_TITLE2, Title2, ARRAY_SIZE(Title2) ); swprintf( wszT, UserCSDString.Length == 0 ? Title1 : Title2, UserBuildString.Buffer, UserCSDString.Buffer, USER_SHARED_DATA->NtSystemRoot ); } else { PWSTR s = wcsrchr( UserTypeString.Buffer, L' ' ); if (s) { s += 1; } else { s = UserTypeString.Buffer; } ServerLoadString( hModuleWin, STR_SAFEMODE_TITLE3, Title1, ARRAY_SIZE(Title1) ); ServerLoadString( hModuleWin, STR_SAFEMODE_TITLE4, Title2, ARRAY_SIZE(Title2) ); swprintf( wszT, UserCSDString.Length == 0 ? Title1 : Title2, UserBuildString.Buffer, UserCSDString.Buffer, s ); } }
int winAccessW(const wchar_t *path, int mode) { DWORD attr = GetFileAttributesW(path); if(attr == 0xffffffff) return -1; if(mode == F_OK) return 0; if(mode & X_OK) if(!(attr & FILE_ATTRIBUTE_DIRECTORY)) { /* Directory, so OK */ /* Look at extension for executables */ wchar_t *p = wcsrchr(path, '.'); if(p == NULL || !((wcsicmp(p, L".exe") == 0) || (wcsicmp(p, L".com") == 0) || (wcsicmp(p, L".bat") == 0) || (wcsicmp(p, L".cmd") == 0)) ) return -1; } { /* Now look for file security info */ SECURITY_DESCRIPTOR *sdPtr = NULL; DWORD size = 0; GENERIC_MAPPING genMap; HANDLE hToken = NULL; DWORD desiredAccess = 0; DWORD grantedAccess = 0; BOOL accessYesNo = FALSE; PRIVILEGE_SET privSet; DWORD privSetSize = sizeof(PRIVILEGE_SET); int error; /* get size */ GetFileSecurityW(path, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION, 0, 0, &size); error = GetLastError(); if (error != ERROR_INSUFFICIENT_BUFFER) return -1; sdPtr = (SECURITY_DESCRIPTOR *) alloca(size); if(!GetFileSecurityW(path, OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION, sdPtr, size, &size)) return -1; /* * Perform security impersonation of the user and open the * resulting thread token. */ if(!ImpersonateSelf(SecurityImpersonation)) return -1; if(!OpenThreadToken(GetCurrentThread (), TOKEN_DUPLICATE | TOKEN_QUERY, FALSE, &hToken)) return -1; if (mode & R_OK) desiredAccess |= FILE_GENERIC_READ; if (mode & W_OK) desiredAccess |= FILE_GENERIC_WRITE; if (mode & X_OK) desiredAccess |= FILE_GENERIC_EXECUTE; memset(&genMap, 0x0, sizeof (GENERIC_MAPPING)); genMap.GenericRead = FILE_GENERIC_READ; genMap.GenericWrite = FILE_GENERIC_WRITE; genMap.GenericExecute = FILE_GENERIC_EXECUTE; genMap.GenericAll = FILE_ALL_ACCESS; if(!AccessCheck(sdPtr, hToken, desiredAccess, &genMap, &privSet, &privSetSize, &grantedAccess, &accessYesNo)) { CloseHandle(hToken); return -1; } CloseHandle(hToken); if (!accessYesNo) return -1; if ((mode & W_OK) && !(attr & FILE_ATTRIBUTE_DIRECTORY) && (attr & FILE_ATTRIBUTE_READONLY)) return -1; } return 0; }
static BOOL ViewTree_LoadTree(HKEY hKey, LPCWSTR pszKeyName, DWORD dwParentID) { DWORD dwIndex; WCHAR szKeyName[64], szText[MAX_PATH], *pch; DWORD Size, Value; PVIEWTREE_ENTRY pAllocated; // resize s_ViewTreeEntries Size = (s_ViewTreeEntryCount + 1) * sizeof(VIEWTREE_ENTRY); pAllocated = (PVIEWTREE_ENTRY)realloc(s_ViewTreeEntries, Size); if (pAllocated == NULL) return FALSE; // failure else s_ViewTreeEntries = pAllocated; PVIEWTREE_ENTRY pEntry = &s_ViewTreeEntries[s_ViewTreeEntryCount]; // dwID, dwParentID, szKeyName pEntry->dwID = s_ViewTreeEntryCount; pEntry->dwParentID = dwParentID; lstrcpynW(pEntry->szKeyName, pszKeyName, _countof(pEntry->szKeyName)); // Text, ResourceID pEntry->szText[0] = 0; pEntry->dwResourceID = 0; szText[0] = 0; Size = sizeof(szText); RegQueryValueExW(hKey, L"Text", NULL, NULL, LPBYTE(szText), &Size); if (szText[0] == L'@') { pch = wcsrchr(szText, L','); if (pch) { *pch = 0; dwIndex = abs(_wtoi(pch + 1)); pEntry->dwResourceID = dwIndex; } HINSTANCE hInst = LoadLibraryW(&szText[1]); LoadStringW(hInst, dwIndex, szText, _countof(szText)); FreeLibrary(hInst); } else { pEntry->dwResourceID = DWORD(-1); } lstrcpynW(pEntry->szText, szText, _countof(pEntry->szText)); // Type szText[0] = 0; RegQueryValueExW(hKey, L"Type", NULL, NULL, LPBYTE(szText), &Size); if (lstrcmpiW(szText, L"checkbox") == 0) pEntry->dwType = AETYPE_CHECKBOX; else if (lstrcmpiW(szText, L"radio") == 0) pEntry->dwType = AETYPE_RADIO; else if (lstrcmpiW(szText, L"group") == 0) pEntry->dwType = AETYPE_GROUP; else return FALSE; // failure pEntry->nIconID = -1; if (pEntry->dwType == AETYPE_GROUP) { // Bitmap (Icon) UINT nIconIndex = 0; Size = sizeof(szText); szText[0] = 0; RegQueryValueExW(hKey, L"Bitmap", NULL, NULL, LPBYTE(szText), &Size); WCHAR szExpanded[MAX_PATH]; ExpandEnvironmentStringsW(szText, szExpanded, _countof(szExpanded)); pch = wcsrchr(szExpanded, L','); if (pch) { *pch = 0; nIconIndex = abs(_wtoi(pch + 1)); } pEntry->nIconID = ViewTree_AddIcon(szExpanded, nIconIndex); } if (pEntry->dwType == AETYPE_GROUP) { pEntry->hkeyRoot = NULL; pEntry->szRegPath[0] = 0; pEntry->szValueName[0] = 0; pEntry->dwCheckedValue = 0; pEntry->bHasUncheckedValue = FALSE; pEntry->dwUncheckedValue = 0; pEntry->dwDefaultValue = 0; pEntry->hItem = NULL; pEntry->bGrayed = FALSE; pEntry->bChecked = FALSE; } else { // HKeyRoot HKEY HKeyRoot = HKEY_CURRENT_USER; Size = sizeof(HKeyRoot); RegQueryValueExW(hKey, L"HKeyRoot", NULL, NULL, LPBYTE(&HKeyRoot), &Size); pEntry->hkeyRoot = HKeyRoot; // RegPath pEntry->szRegPath[0] = 0; Size = sizeof(szText); RegQueryValueExW(hKey, L"RegPath", NULL, NULL, LPBYTE(szText), &Size); lstrcpynW(pEntry->szRegPath, szText, _countof(pEntry->szRegPath)); // ValueName pEntry->szValueName[0] = 0; Size = sizeof(szText); RegQueryValueExW(hKey, L"ValueName", NULL, NULL, LPBYTE(szText), &Size); lstrcpynW(pEntry->szValueName, szText, _countof(pEntry->szValueName)); // CheckedValue Size = sizeof(Value); Value = 0x00000001; RegQueryValueExW(hKey, L"CheckedValue", NULL, NULL, LPBYTE(&Value), &Size); pEntry->dwCheckedValue = Value; // UncheckedValue Size = sizeof(Value); Value = 0x00000000; pEntry->bHasUncheckedValue = TRUE; if (RegQueryValueExW(hKey, L"UncheckedValue", NULL, NULL, LPBYTE(&Value), &Size) != ERROR_SUCCESS) { pEntry->bHasUncheckedValue = FALSE; } pEntry->dwUncheckedValue = Value; // DefaultValue Size = sizeof(Value); Value = 0x00000001; RegQueryValueExW(hKey, L"DefaultValue", NULL, NULL, LPBYTE(&Value), &Size); pEntry->dwDefaultValue = Value; // hItem pEntry->hItem = NULL; // bGrayed, bChecked HKEY hkeyTarget; Value = pEntry->dwDefaultValue; pEntry->bGrayed = TRUE; if (RegOpenKeyExW(HKEY(pEntry->hkeyRoot), pEntry->szRegPath, 0, KEY_READ, &hkeyTarget) == ERROR_SUCCESS) { Size = sizeof(Value); if (RegQueryValueExW(hkeyTarget, pEntry->szValueName, NULL, NULL, LPBYTE(&Value), &Size) == ERROR_SUCCESS) { pEntry->bGrayed = FALSE; } RegCloseKey(hkeyTarget); } pEntry->bChecked = (Value == pEntry->dwCheckedValue); } // Grayed (ReactOS extension) Size = sizeof(Value); Value = FALSE; RegQueryValueExW(hKey, L"Grayed", NULL, NULL, LPBYTE(&Value), &Size); if (!pEntry->bGrayed) pEntry->bGrayed = Value; BOOL bIsGroup = (pEntry->dwType == AETYPE_GROUP); dwParentID = pEntry->dwID; ++s_ViewTreeEntryCount; if (!bIsGroup) return TRUE; // success // load the children dwIndex = 0; while (RegEnumKeyW(hKey, dwIndex, szKeyName, _countof(szKeyName)) == ERROR_SUCCESS) { HKEY hkeyChild; if (RegOpenKeyExW(hKey, szKeyName, 0, KEY_READ, &hkeyChild) != ERROR_SUCCESS) { ++dwIndex; continue; // failure } ViewTree_LoadTree(hkeyChild, szKeyName, dwParentID); RegCloseKey(hkeyChild); ++dwIndex; } return TRUE; // success }
static wcstring file_get_desc(const wcstring &filename, int lstat_res, struct stat lbuf, int stat_res, struct stat buf, int err) { const wchar_t *suffix; if (!lstat_res) { if (S_ISLNK(lbuf.st_mode)) { if (!stat_res) { if (S_ISDIR(buf.st_mode)) { return COMPLETE_DIRECTORY_SYMLINK_DESC; } else { if ((buf.st_mode & S_IXUSR) || (buf.st_mode & S_IXGRP) || (buf.st_mode & S_IXOTH)) { if (waccess(filename, X_OK) == 0) { /* Weird group permissions and other such issues make it non-trivial to find out if we can actually execute a file using the result from stat. It is much safer to use the access function, since it tells us exactly what we want to know. */ return COMPLETE_EXEC_LINK_DESC; } } } return COMPLETE_SYMLINK_DESC; } else { switch (err) { case ENOENT: { return COMPLETE_ROTTEN_SYMLINK_DESC; } case ELOOP: { return COMPLETE_LOOP_SYMLINK_DESC; } } /* On unknown errors we do nothing. The file will be given the default 'File' description or one based on the suffix. */ } } else if (S_ISCHR(buf.st_mode)) { return COMPLETE_CHAR_DESC; } else if (S_ISBLK(buf.st_mode)) { return COMPLETE_BLOCK_DESC; } else if (S_ISFIFO(buf.st_mode)) { return COMPLETE_FIFO_DESC; } else if (S_ISSOCK(buf.st_mode)) { return COMPLETE_SOCKET_DESC; } else if (S_ISDIR(buf.st_mode)) { return COMPLETE_DIRECTORY_DESC; } else { if ((buf.st_mode & S_IXUSR) || (buf.st_mode & S_IXGRP) || (buf.st_mode & S_IXOTH)) { if (waccess(filename, X_OK) == 0) { /* Weird group permissions and other such issues make it non-trivial to find out if we can actually execute a file using the result from stat. It is much safer to use the access function, since it tells us exactly what we want to know. */ return COMPLETE_EXEC_DESC; } } } } suffix = wcsrchr(filename.c_str(), L'.'); if (suffix != 0 && !wcsrchr(suffix, L'/')) { return complete_get_desc_suffix(suffix); } return COMPLETE_FILE_DESC ; }
void CDropbox::RequestAccountInfo() { HttpRequest *request = new HttpRequest(hNetlibUser, REQUEST_GET, DROPBOX_API_URL "/account/info"); request->AddBearerAuthHeader(db_get_sa(NULL, MODULE, "TokenSecret")); mir_ptr<NETLIBHTTPREQUEST> response(request->Send()); delete request; MCONTACT hContact = CDropbox::GetDefaultContact(); if (response && response->resultCode == HTTP_STATUS_OK) { JSONROOT root(response->pData); if (root) { JSONNODE *node = json_get(root, "referral_link"); if (node) { ptrW referral_link = ptrW(json_as_string(node)); db_set_ws(hContact, MODULE, "Homepage", referral_link); } node = json_get(root, "display_name"); if (node) { ptrW display_name = ptrW(json_as_string(node)); wchar_t *sep = wcsrchr(display_name, L' '); if (sep) { db_set_ws(hContact, MODULE, "LastName", sep + 1); display_name[wcslen(display_name) - wcslen(sep)] = '\0'; db_set_ws(hContact, MODULE, "FirstName", display_name); } else { db_set_ws(hContact, MODULE, "FirstName", display_name); db_unset(hContact, MODULE, "LastName"); } } node = json_get(root, "country"); if (node) { ptrW isocodeW(json_as_string(node)); ptrA isocode(mir_u2a(isocodeW)); if (!strlen(isocode)) db_unset(hContact, MODULE, "Country"); else { char *country = (char *)CallService(MS_UTILS_GETCOUNTRYBYISOCODE, (WPARAM)isocode, 0); db_set_s(hContact, MODULE, "Country", country); } } node = json_get(root, "quota_info"); JSONNODE *nroot = json_as_node(node); if (nroot) { node = json_get(nroot, "shared"); if (node) db_set_dw(hContact, MODULE, "SharedQuota", json_as_int(node)); node = json_get(nroot, "normal"); if (node) db_set_dw(hContact, MODULE, "NormalQuota", json_as_int(node)); node = json_get(nroot, "quota"); if (node) db_set_dw(hContact, MODULE, "TotalQuota", json_as_int(node)); } } } HandleHttpResponseError(hNetlibUser, response); }
// dump - Dumps a nicely formatted rendition of the CallStack, including // symbolic information (function names and line numbers) if available. // // Note: The symbol handler must be initialized prior to calling this // function. // // - showinternalframes (IN): If true, then all frames in the CallStack will be // dumped. Otherwise, frames internal to the heap will not be dumped. // // Return Value: // // None. // void CallStack::dump(BOOL showInternalFrames, UINT start_frame) const { // The stack was dumped already if (m_resolved) { dumpResolved(); return; } if (m_status & CALLSTACK_STATUS_INCOMPLETE) { // This call stack appears to be incomplete. Using StackWalk64 may be // more reliable. Report(L" HINT: The following call stack may be incomplete. Setting \"StackWalkMethod\"\n" L" in the vld.ini file to \"safe\" instead of \"fast\" may result in a more\n" L" complete stack trace.\n"); } IMAGEHLP_LINE64 sourceInfo = { 0 }; sourceInfo.SizeOfStruct = sizeof(IMAGEHLP_LINE64); BYTE symbolBuffer [sizeof(SYMBOL_INFO) + MAX_SYMBOL_NAME_SIZE] = { 0 }; WCHAR lowerCaseName [MAX_PATH]; WCHAR callingModuleName [MAX_PATH]; const size_t max_size = MAXREPORTLENGTH + 1; // Iterate through each frame in the call stack. for (UINT32 frame = start_frame; frame < m_size; frame++) { // Try to get the source file and line number associated with // this program counter address. SIZE_T programCounter = (*this)[frame]; g_symbolLock.Enter(); BOOL foundline = FALSE; DWORD displacement = 0; DbgTrace(L"dbghelp32.dll %i: SymGetLineFromAddrW64\n", GetCurrentThreadId()); foundline = SymGetLineFromAddrW64(g_currentProcess, programCounter, &displacement, &sourceInfo); if (foundline && !showInternalFrames) { wcscpy_s(lowerCaseName, sourceInfo.FileName); _wcslwr_s(lowerCaseName, wcslen(lowerCaseName) + 1); if (isInternalModule(lowerCaseName)) { // Don't show frames in files internal to the heap. g_symbolLock.Leave(); continue; } } // Initialize structures passed to the symbol handler. SYMBOL_INFO* functionInfo = (SYMBOL_INFO*)&symbolBuffer; functionInfo->SizeOfStruct = sizeof(SYMBOL_INFO); functionInfo->MaxNameLen = MAX_SYMBOL_NAME_LENGTH; // Try to get the name of the function containing this program // counter address. DWORD64 displacement64 = 0; LPWSTR functionName; DbgTrace(L"dbghelp32.dll %i: SymFromAddrW\n", GetCurrentThreadId()); if (SymFromAddrW(g_currentProcess, programCounter, &displacement64, functionInfo)) { functionName = functionInfo->Name; } else { // GetFormattedMessage( GetLastError() ); functionName = L"(Function name unavailable)"; displacement64 = 0; } g_symbolLock.Leave(); HMODULE hCallingModule = GetCallingModule(programCounter); LPWSTR moduleName = L"(Module name unavailable)"; if (hCallingModule && GetModuleFileName(hCallingModule, callingModuleName, _countof(callingModuleName)) > 0) { moduleName = wcsrchr(callingModuleName, L'\\'); if (moduleName == NULL) moduleName = wcsrchr(callingModuleName, L'/'); if (moduleName != NULL) moduleName++; else moduleName = callingModuleName; } // Use static here to increase performance, and avoid heap allocs. Hopefully this won't // prove to be an issue in thread safety. If it does, it will have to be simply non-static. static WCHAR stack_line[MAXREPORTLENGTH + 1] = L""; int NumChars = -1; // Display the current stack frame's information. if (foundline) { if (displacement == 0) NumChars = _snwprintf_s(stack_line, max_size, _TRUNCATE, L" %s (%d): %s!%s\n", sourceInfo.FileName, sourceInfo.LineNumber, moduleName, functionName); else NumChars = _snwprintf_s(stack_line, max_size, _TRUNCATE, L" %s (%d): %s!%s + 0x%X bytes\n", sourceInfo.FileName, sourceInfo.LineNumber, moduleName, functionName, displacement); } else { if (displacement64 == 0) NumChars = _snwprintf_s(stack_line, max_size, _TRUNCATE, L" " ADDRESSFORMAT L" (File and line number not available): %s!%s\n", programCounter, moduleName, functionName); else NumChars = _snwprintf_s(stack_line, max_size, _TRUNCATE, L" " ADDRESSFORMAT L" (File and line number not available): %s!%s + 0x%X bytes\n", programCounter, moduleName, functionName, (DWORD)displacement64); } Print(stack_line); } }
// используется в GUI при загрузке настроек void FindComspec(ConEmuComspec* pOpt, bool bCmdAlso /*= true*/) { if (!pOpt) return; pOpt->Comspec32[0] = 0; pOpt->Comspec64[0] = 0; // Ищем tcc.exe if (pOpt->csType == cst_AutoTccCmd) { HKEY hk; BOOL bWin64 = IsWindows64(); wchar_t szPath[MAX_PATH+1]; // If tcc.exe can be found near to ConEmu location LPCWSTR ppszPredefined[] = { L"%ConEmuBaseDir%\\tcc.exe", L"%ConEmuDir%\\tcc.exe", // Sort of PortableApps locations L"%ConEmuDir%\\..\\tcc\\tcc.exe", L"%ConEmuDir%\\..\\..\\tcc\\tcc.exe", // End of predefined list NULL}; for (INT_PTR i = 0; ppszPredefined[i]; i++) { DWORD nExpand = ExpandEnvironmentStrings(ppszPredefined[i], szPath, countof(szPath)); if (nExpand && (nExpand < countof(szPath))) { if (FileExists(szPath)) { wcscpy_c(pOpt->Comspec32, szPath); wcscpy_c(pOpt->Comspec64, szPath); break; } } } // On this step - check "Take Command"! if (!*pOpt->Comspec32 || !*pOpt->Comspec64) { // [HKEY_LOCAL_MACHINE\SOFTWARE\JP Software\Take Command 13.0] // @="\"C:\\Program Files\\JPSoft\\TCMD13\\tcmd.exe\"" for (int b = 0; b <= 1; b++) { // b==0 - 32bit, b==1 - 64bit if (b && !bWin64) continue; bool bFound = false; DWORD nOpt = (b == 0) ? (bWin64 ? KEY_WOW64_32KEY : 0) : (bWin64 ? KEY_WOW64_64KEY : 0); if (!RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\JP Software", 0, KEY_READ|nOpt, &hk)) { wchar_t szName[MAX_PATH+1]; DWORD nLen; for (DWORD k = 0; !bFound && !RegEnumKeyEx(hk, k, szName, &(nLen = countof(szName)-1), 0,0,0,0); k++) { HKEY hk2; if (!RegOpenKeyEx(hk, szName, 0, KEY_READ|nOpt, &hk2)) { // Just in case, check "Path" too LPCWSTR rsNames[] = {NULL, L"Path"}; for (size_t n = 0; n < countof(rsNames); n++) { ZeroStruct(szPath); DWORD nSize = (countof(szPath)-1)*sizeof(szPath[0]); if (!RegQueryValueExW(hk2, rsNames[n], NULL, NULL, (LPBYTE)szPath, &nSize) && *szPath) { wchar_t* psz, *pszEnd; psz = (wchar_t*)Unquote(szPath, true); pszEnd = wcsrchr(psz, L'\\'); if (!pszEnd || lstrcmpi(pszEnd, L"\\tcmd.exe") || !FileExists(psz)) continue; lstrcpyn(pszEnd+1, L"tcc.exe", 8); if (FileExists(psz)) { bFound = true; if (b == 0) wcscpy_c(pOpt->Comspec32, psz); else wcscpy_c(pOpt->Comspec64, psz); } } } // for (size_t n = 0; n < countof(rsNames); n++) RegCloseKey(hk2); } } // for, подключи RegCloseKey(hk); } // L"SOFTWARE\\JP Software" } // for (int b = 0; b <= 1; b++) // Если установлен TCMD - предпочтительно использовать именно его, независимо от битности if (*pOpt->Comspec32 && !*pOpt->Comspec64) wcscpy_c(pOpt->Comspec64, pOpt->Comspec32); else if (*pOpt->Comspec64 && !*pOpt->Comspec32) wcscpy_c(pOpt->Comspec32, pOpt->Comspec64); } // If "Take Command" not installed - try "TCC/LE" if (!*pOpt->Comspec32 || !*pOpt->Comspec64) { // [HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\{16A21882-4138-4ADA-A390-F62DC27E4504}] // "DisplayVersion"="13.04.60" // "Publisher"="JP Software" // "DisplayName"="Take Command 13.0" // или // "DisplayName"="TCC/LE 13.0" // и наконец // "InstallLocation"="C:\\Program Files\\JPSoft\\TCMD13\\" for (int b = 0; b <= 1; b++) { // b==0 - 32bit, b==1 - 64bit if (b && !bWin64) continue; if (((b == 0) ? *pOpt->Comspec32 : *pOpt->Comspec64)) continue; // этот уже нашелся в TCMD bool bFound = false; DWORD nOpt = (b == 0) ? (bWin64 ? KEY_WOW64_32KEY : 0) : (bWin64 ? KEY_WOW64_64KEY : 0); if (!RegOpenKeyEx(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall", 0, KEY_READ|nOpt, &hk)) { wchar_t szName[MAX_PATH+1]; DWORD nLen; for (DWORD n = 0; !bFound && !RegEnumKeyEx(hk, n, szName, &(nLen = countof(szName)-1), 0,0,0,0); n++) { if (*szName != L'{') continue; HKEY hk2; if (!RegOpenKeyEx(hk, szName, 0, KEY_READ|nOpt, &hk2)) { ZeroStruct(szPath); DWORD nSize = (countof(szPath) - 1)*sizeof(szPath[0]); if (!RegQueryValueExW(hk2, L"Publisher", NULL, NULL, (LPBYTE)szPath, &nSize) && !lstrcmpi(szPath, L"JP Software")) { nSize = (countof(szPath)-12)*sizeof(szPath[0]); if (!RegQueryValueExW(hk2, L"InstallLocation", NULL, NULL, (LPBYTE)szPath, &nSize) && *szPath) { wchar_t* psz, *pszEnd; if (szPath[0] == L'"') { psz = szPath + 1; pszEnd = wcschr(psz, L'"'); if (pszEnd) *pszEnd = 0; } else { psz = szPath; } if (*psz) { pszEnd = psz+lstrlen(psz); if (*(pszEnd-1) != L'\\') *(pszEnd++) = L'\\'; lstrcpyn(pszEnd, L"tcc.exe", 8); if (FileExists(psz)) { bFound = true; if (b == 0) wcscpy_c(pOpt->Comspec32, psz); else wcscpy_c(pOpt->Comspec64, psz); } } } } RegCloseKey(hk2); } } // for, подключи RegCloseKey(hk); } // L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall" } // for (int b = 0; b <= 1; b++) } // Попытаться "в лоб" из "Program Files" if (!*pOpt->Comspec32 && !*pOpt->Comspec64) { const wchar_t* pszTcmd = L"C:\\Program Files\\JPSoft\\TCMD13\\tcc.exe"; const wchar_t* pszTccLe = L"C:\\Program Files\\JPSoft\\TCCLE13\\tcc.exe"; if (FileExists(pszTcmd)) wcscpy_c(pOpt->Comspec32, pszTcmd); else if (FileExists(pszTccLe)) wcscpy_c(pOpt->Comspec32, pszTccLe); } if (*pOpt->Comspec32 && !*pOpt->Comspec64) wcscpy_c(pOpt->Comspec64, pOpt->Comspec32); else if (*pOpt->Comspec64 && !*pOpt->Comspec32) wcscpy_c(pOpt->Comspec32, pOpt->Comspec64); } // if (pOpt->csType == cst_AutoTccCmd) // С поиском tcc закончили. Теперь, если pOpt->Comspec32/pOpt->Comspec64 остались не заполнены // нужно сначала попытаться обработать переменную окружения ComSpec, а потом - просто "cmd.exe" if (!*pOpt->Comspec32) GetComspecFromEnvVar(pOpt->Comspec32, countof(pOpt->Comspec32), csb_x32); if (!*pOpt->Comspec64) GetComspecFromEnvVar(pOpt->Comspec64, countof(pOpt->Comspec64), csb_x64); }
int APIENTRY wWinMain(HINSTANCE instance, HINSTANCE previousInstance, LPTSTR commandLine, int showState) { INT_PTR result; WCHAR qrexecClientPath[MAX_PATH] = { 0 }; WCHAR *qrexecClientCmdLine; size_t cchQrexecClientCmdLine; WCHAR *pathSeparator; PROCESS_INFORMATION pi; STARTUPINFO si = { 0 }; DWORD status; result = DialogBox( instance, // application instance MAKEINTRESOURCE(IDD_INPUTBOX), // dialog box resource NULL, // owner window InputBoxProc // dialog box window procedure ); switch (result) { case 0: // cancel return 0; case -1: // error return 1; } // build qrexec-client-vm path, first get our own if (!GetModuleFileName(NULL, qrexecClientPath, RTL_NUMBER_OF(qrexecClientPath))) { status = perror("GetModuleFileName"); ReportError(L"Failed to get " QREXEC_CLIENT_VM L" path"); return status; } // cut off file name (qrexec_agent.exe) pathSeparator = wcsrchr(qrexecClientPath, L'\\'); if (!pathSeparator) { LogError("Bad executable path"); ReportError(L"Cannot find dir containing " QREXEC_CLIENT_VM); return ERROR_BAD_PATHNAME; } // Leave trailing backslash pathSeparator++; *pathSeparator = L'\0'; // append target executable PathAppend(qrexecClientPath, QREXEC_CLIENT_VM); cchQrexecClientCmdLine = wcslen(QREXEC_CLIENT_VM) + wcslen((WCHAR *) result) + wcslen(commandLine) + 3; qrexecClientCmdLine = malloc(cchQrexecClientCmdLine * sizeof(WCHAR)); if (!qrexecClientCmdLine) { LogError("malloc failed"); ReportError(L"Out of memory"); return ERROR_NOT_ENOUGH_MEMORY; } if (FAILED(StringCchPrintf(qrexecClientCmdLine, cchQrexecClientCmdLine, QREXEC_CLIENT_VM L" %s%c%s", (WCHAR *) result, QUBES_ARGUMENT_SEPARATOR, commandLine))) { LogError("Failed to construct command line"); ReportError(L"Failed to construct command line"); return ERROR_BAD_PATHNAME; } LogDebug("executing command: '%s'", qrexecClientCmdLine); si.cb = sizeof(si); if (!CreateProcess(qrexecClientPath, qrexecClientCmdLine, NULL, NULL, TRUE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi)) { status = perror("CreateProcess"); ReportError(L"Failed to execute qrexec-client-vm.exe"); return status; } return ERROR_SUCCESS; }
const wchar_t* CRes::GetName(CString &FileName) { return wcsrchr(FileName.GetString(), _T('/'))+1; }
BOOL CYYManager::InitFactory() { WCHAR wzSelfPath[MAX_PATH]; memset( wzSelfPath, 0, sizeof(wzSelfPath) ); GetModuleFileNameW( NULL, wzSelfPath, sizeof(wzSelfPath) ); LPWSTR lpInsertPos = wcsrchr( wzSelfPath, L'\\' ); *lpInsertPos = L'\0'; lstrcatW( wzSelfPath, L"\\pipFactory.dll" ); m_hFactory = LoadLibraryW( wzSelfPath ); if( m_hFactory == NULL ) return FALSE; m_pfnInitInterface = (PFN_INITYYINTERFACE)GetProcAddress( m_hFactory, "YYPIP_InitInterface" ); if( m_pfnInitInterface == NULL ) return FALSE; m_pfnGetInterface = (PFN_GETYYINTERFACE)GetProcAddress( m_hFactory, "YYPIP_GetInterface" ); if( m_pfnGetInterface == NULL ) return FALSE; //call factory init func if( m_pfnInitInterface() == -1 ) return FALSE; ///////////////////////////////////////////////////////////////////////// //all game must be call this func to show yy window m_pfnRunService = (PFN_RUNSERVICE)m_pfnGetInterface( "YYPIP_RunService" ); if( m_pfnRunService == NULL ) return FALSE; m_pfnLoadInGame = (PFN_LOADINGAME)m_pfnGetInterface( "YYPIP_LoadInGame" ); if( m_pfnLoadInGame == NULL ) return FALSE; m_pfnFreeGame = (PFN_FREEINGAME)m_pfnGetInterface( "YYPIP_FreeInGame" ); if( m_pfnFreeGame == NULL ) return FALSE; m_pfnCheckClient = (PFN_CHECKCLIENT)m_pfnGetInterface( "YYPIP_CheckYYClient" ); if( m_pfnCheckClient == NULL ) return FALSE; m_pfnIsPipSuccess = (PFN_ISPIPSUCCESS)m_pfnGetInterface( "YYPIP_IsPipRunSuccess" ); if( m_pfnIsPipSuccess == NULL ) return FALSE; ///////////////////////////////////////////////////////////////////////// //sometimes call this func to show yy window m_pfnMouseInput = (PFN_MOUSEINPUT)m_pfnGetInterface( "YYPIP_MouseInput" ); if( m_pfnMouseInput == NULL ) return FALSE; m_pfnSetMainWnd = (PFN_SETMAINWND)m_pfnGetInterface( "YYPIP_SetMainWnd" ); if( m_pfnSetMainWnd == NULL ) return FALSE; m_pfnCreateUI = (PFN_CREATEUI)m_pfnGetInterface( "YYPIP_CreateUI" ); if( m_pfnCreateUI == NULL ) return FALSE; m_pfnDestoryUI = (PFN_DESTORYUI)m_pfnGetInterface( "YYPIP_DestoryUI" ); if( m_pfnDestoryUI == NULL ) return FALSE; m_pfnRenderGUI = (PFN_RENDERGUI)m_pfnGetInterface( "YYPIP_RenderGUI" ); if( m_pfnRenderGUI == NULL ) return FALSE; m_pfnGameWndMsg = (PFN_GAMEWNDMSG)m_pfnGetInterface( "YYPIP_GameWndMessage" ); if( m_pfnGameWndMsg == NULL ) return FALSE; ///////////////////////////////////////////////////////////////////////// //game used yy voice channel m_pfnJoinChannel = (PFN_JOINCHANNEL)m_pfnGetInterface( "YYPIP_JoinChannel" ); if( m_pfnJoinChannel == NULL ) return FALSE; m_pfnSetTeamAdmin = (PFN_SETTEAMADMIN)m_pfnGetInterface( "YYPIP_SetTeamAdmin" ); if( m_pfnSetTeamAdmin == NULL ) return FALSE; m_pfnSetUserName = (PFN_SETUSERNAME)m_pfnGetInterface( "YYPIP_SetUserName" ); if( m_pfnSetUserName == NULL ) return FALSE; m_pfnJoinTeam = (PFN_JOINTEAM)m_pfnGetInterface( "YYPIP_JoinTeam" ); if( m_pfnJoinTeam == NULL ) return FALSE; m_pfnSetTeamDevice = (PFN_SETTEAMDEVICE)m_pfnGetInterface( "YYPIP_SetTeamDevice" ); if( m_pfnSetTeamDevice == NULL ) return FALSE; m_pfnSetTeamVoice = (PFN_SETTEAMVOICE)m_pfnGetInterface( "YYPIP_SetTeamVoice" ); if( m_pfnSetTeamVoice == NULL ) return FALSE; m_pfnLockTeamVoice = (PFN_LOCKTEAMVOICE)m_pfnGetInterface( "YYPIP_LockTeamVoice" ); if( m_pfnLockTeamVoice == NULL ) return FALSE; ///////////////////////////////////////////////////////////////////////// //game to channel yy voice window m_pfnGetPipShow = (PFN_GETPIPSHOW)m_pfnGetInterface( "YYPIP_GetPipShow" ); if( m_pfnGetPipShow == NULL ) return FALSE; m_pfnSetPipShow = (PFN_SETPIPSHOW)m_pfnGetInterface( "YYPIP_SetPipShow" ); if( m_pfnSetPipShow == NULL ) return FALSE; m_pfnSetMsgShow = (PFN_SETMSGSHOW)m_pfnGetInterface( "YYPIP_SetMsgShow" ); if( m_pfnSetMsgShow == NULL ) return FALSE; m_pfnMouseShow = (PFN_SETMOUSESHOW)m_pfnGetInterface( "YYPIP_SetMouseShow" ); if( m_pfnMouseShow == NULL ) return FALSE; m_pfnLockWnd = (PFN_LOCKWINDOW)m_pfnGetInterface( "YYPIP_LockWindow" ); if( m_pfnLockWnd == NULL ) return FALSE; m_pfnMoveWnd = (PFN_MOVEWINDOW)m_pfnGetInterface( "YYPIP_MoveWindow" ); if( m_pfnMoveWnd == NULL ) return FALSE; ///////////////////////////////////////////////////////////////////////// //game to used open id func m_pfnShowOpid = (PFN_SHOWOPENID)m_pfnGetInterface( "YYPIP_ShowOpenId" ); if( m_pfnShowOpid == NULL ) return FALSE; m_pfnLoginSucceed = (PFN_LOGINSUCCEED)m_pfnGetInterface( "YYPIP_LoginSucceed" ); if( m_pfnLoginSucceed == NULL ) return FALSE; m_pfnLoginFailure = (PFN_LOGINFAILURE)m_pfnGetInterface( "YYPIP_LoginFailure" ); if( m_pfnLoginFailure == NULL ) return FALSE; m_pfnSetLoginKey = (PFN_SETLOGINKEY)m_pfnGetInterface( "YYPIP_SetLoginKey" ); if( m_pfnSetLoginKey == NULL ) return FALSE; m_pfnSetCallBack = (PFN_SETCALLBACK)m_pfnGetInterface( "YYPIP_SetCallBackFunc" ); if( m_pfnSetCallBack == NULL ) return FALSE; return TRUE; }
/*enumerate directories*/ GF_EXPORT GF_Err gf_enum_directory(const char *dir, Bool enum_directory, gf_enum_dir_item enum_dir_fct, void *cbck, const char *filter) { #ifdef WIN32 wchar_t item_path[GF_MAX_PATH]; #else char item_path[GF_MAX_PATH]; #endif GF_FileEnumInfo file_info; #if defined(_WIN32_WCE) char _path[GF_MAX_PATH]; unsigned short path[GF_MAX_PATH]; unsigned short w_filter[GF_MAX_PATH]; char file[GF_MAX_PATH]; #elif defined(WIN32) wchar_t path[GF_MAX_PATH], *file; wchar_t w_filter[GF_MAX_PATH]; wchar_t w_dir[GF_MAX_PATH]; char *mbs_file, *mbs_item_path; #else char path[GF_MAX_PATH], *file; #endif #ifdef WIN32 WIN32_FIND_DATAW FindData; HANDLE SearchH; #else DIR *the_dir; struct dirent* the_file; struct stat st; #endif if (!dir || !enum_dir_fct) return GF_BAD_PARAM; if (filter && (!strcmp(filter, "*") || !filter[0])) filter=NULL; memset(&file_info, 0, sizeof(GF_FileEnumInfo) ); if (!strcmp(dir, "/")) { #if defined(WIN32) && !defined(_WIN32_WCE) u32 len; char *drives, *volume; len = GetLogicalDriveStrings(0, NULL); drives = (char*)gf_malloc(sizeof(char)*(len+1)); drives[0]=0; GetLogicalDriveStrings(len, drives); len = (u32) strlen(drives); volume = drives; file_info.directory = GF_TRUE; file_info.drive = GF_TRUE; while (len) { enum_dir_fct(cbck, volume, "", &file_info); volume += len+1; len = (u32) strlen(volume); } gf_free(drives); return GF_OK; #elif defined(__SYMBIAN32__) RFs iFs; TDriveList aList; iFs.Connect(); iFs.DriveList(aList); for (TInt i=0; i<KMaxDrives; i++) { if (aList[i]) { char szDrive[10]; TChar aDrive; iFs.DriveToChar(i, aDrive); sprintf(szDrive, "%c:", (TUint)aDrive); enum_dir_fct(cbck, szDrive, "", &file_info); } } iFs.Close(); FlushItemList(); return GF_OK; #endif } #if defined (_WIN32_WCE) switch (dir[strlen(dir) - 1]) { case '/': case '\\': sprintf(_path, "%s*", dir); break; default: sprintf(_path, "%s%c*", dir, GF_PATH_SEPARATOR); break; } CE_CharToWide(_path, path); CE_CharToWide((char *)filter, w_filter); #elif defined(WIN32) { const char* tmpdir = dir; gf_utf8_mbstowcs(w_dir, sizeof(w_dir), &tmpdir); } switch (w_dir[wcslen(w_dir) - 1]) { case '/': case '\\': swprintf(path, MAX_PATH, L"%s*", w_dir); break; default: swprintf(path, MAX_PATH, L"%s%c*", w_dir, GF_PATH_SEPARATOR); break; } { const char* tmpfilter = filter; gf_utf8_mbstowcs(w_filter, sizeof(w_filter), &tmpfilter); } #else strcpy(path, dir); if (path[strlen(path)-1] != '/') strcat(path, "/"); #endif #ifdef WIN32 SearchH= FindFirstFileW(path, &FindData); if (SearchH == INVALID_HANDLE_VALUE) return GF_IO_ERR; #if defined (_WIN32_WCE) _path[strlen(_path)-1] = 0; #else path[wcslen(path)-1] = 0; #endif while (SearchH != INVALID_HANDLE_VALUE) { #else the_dir = opendir(path); if (the_dir == NULL) { GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] Cannot open directory %s for enumeration: %d\n", path, errno)); return GF_IO_ERR; } the_file = readdir(the_dir); while (the_file) { #endif memset(&file_info, 0, sizeof(GF_FileEnumInfo) ); #if defined (_WIN32_WCE) if (!wcscmp(FindData.cFileName, _T(".") )) goto next; if (!wcscmp(FindData.cFileName, _T("..") )) goto next; #elif defined(WIN32) if (!wcscmp(FindData.cFileName, L".")) goto next; if (!wcscmp(FindData.cFileName, L"..")) goto next; #else if (!strcmp(the_file->d_name, "..")) goto next; if (the_file->d_name[0] == '.') goto next; #endif #ifdef WIN32 file_info.directory = (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? GF_TRUE : GF_FALSE; if (!enum_directory && file_info.directory) goto next; if (enum_directory && !file_info.directory) goto next; #endif if (filter) { #if defined (_WIN32_WCE) short ext[30]; short *sep = wcsrchr(FindData.cFileName, (wchar_t) '.'); if (!sep) goto next; wcscpy(ext, sep+1); wcslwr(ext); if (!wcsstr(w_filter, ext)) goto next; #elif defined(WIN32) wchar_t ext[30]; wchar_t *sep = wcsrchr(FindData.cFileName, L'.'); if (!sep) goto next; wcscpy(ext, sep+1); wcslwr(ext); if (!wcsstr(w_filter, ext)) goto next; #else char ext[30]; char *sep = strrchr(the_file->d_name, '.'); if (!sep) goto next; strcpy(ext, sep+1); strlwr(ext); if (!strstr(filter, sep+1)) goto next; #endif } #if defined(WIN32) file_info.hidden = (FindData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) ? GF_TRUE : GF_FALSE; file_info.system = (FindData.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) ? GF_TRUE : GF_FALSE; file_info.size = MAXDWORD; file_info.size += 1; file_info.size *= FindData.nFileSizeHigh; file_info.size += FindData.nFileSizeLow; file_info.last_modified = (u64) ((*(LONGLONG *) &FindData.ftLastWriteTime - TIMESPEC_TO_FILETIME_OFFSET) / 10000000); #endif #if defined (_WIN32_WCE) CE_WideToChar(FindData.cFileName, file); strcpy(item_path, _path); strcat(item_path, file); #elif defined(WIN32) wcscpy(item_path, path); wcscat(item_path, FindData.cFileName); file = FindData.cFileName; #else strcpy(item_path, path); strcat(item_path, the_file->d_name); GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] Checking file %s for enum\n", item_path)); if (stat( item_path, &st ) != 0) goto next; file_info.directory = ((st.st_mode & S_IFMT) == S_IFDIR) ? GF_TRUE : GF_FALSE; if (enum_directory && !file_info.directory) goto next; if (!enum_directory && file_info.directory) goto next; file_info.size = st.st_size; { struct tm _t = * gmtime(& st.st_mtime); file_info.last_modified = mktime(&_t); } file = the_file->d_name; if (file && file[0]=='.') file_info.hidden = 1; if (file_info.directory) { char * parent_name = strrchr(item_path, '/'); if (!parent_name) { file_info.drive = GF_TRUE; } else { struct stat st_parent; parent_name[0] = 0; if (stat(item_path, &st_parent) == 0) { if ((st.st_dev != st_parent.st_dev) || ((st.st_dev == st_parent.st_dev) && (st.st_ino == st_parent.st_ino))) { file_info.drive = GF_TRUE; } } parent_name[0] = '/'; } } #endif #ifdef WIN32 mbs_file = wcs_to_utf8(file); mbs_item_path = wcs_to_utf8(item_path); if (!mbs_file || !mbs_item_path) { if (mbs_file) gf_free(mbs_file); if (mbs_item_path) gf_free(mbs_item_path); return GF_IO_ERR; } if (enum_dir_fct(cbck, mbs_file, mbs_item_path, &file_info)) { BOOL ret = FindClose(SearchH); if (!ret) { DWORD err = GetLastError(); GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[core] FindClose() in gf_enum_directory() returned(1) the following error code: %d\n", err)); } #else if (enum_dir_fct(cbck, file, item_path, &file_info)) { #endif break; } #ifdef WIN32 gf_free(mbs_file); gf_free(mbs_item_path); #endif next: #ifdef WIN32 if (!FindNextFileW(SearchH, &FindData)) { BOOL ret = FindClose(SearchH); if (!ret) { DWORD err = GetLastError(); GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[core] FindClose() in gf_enum_directory() returned(2) the following error code: %d\n", err)); } break; } #else the_file = readdir(the_dir); #endif } #ifndef WIN32 closedir(the_dir); #endif return GF_OK; } GF_EXPORT u64 gf_ftell(FILE *fp) { #if defined(_WIN32_WCE) return (u64) ftell(fp); #elif defined(GPAC_CONFIG_WIN32) && !defined(__CYGWIN__) /* mingw or cygwin */ #if (_FILE_OFFSET_BITS >= 64) return (u64) ftello64(fp); #else return (u64) ftell(fp); #endif #elif defined(WIN32) return (u64) _ftelli64(fp); #elif defined(GPAC_CONFIG_LINUX) && !defined(GPAC_ANDROID) return (u64) ftello64(fp); #elif (defined(GPAC_CONFIG_FREEBSD) || defined(GPAC_CONFIG_DARWIN)) return (u64) ftello(fp); #else return (u64) ftell(fp); #endif } GF_EXPORT u64 gf_fseek(FILE *fp, s64 offset, s32 whence) { #if defined(_WIN32_WCE) return (u64) fseek(fp, (s32) offset, whence); #elif defined(GPAC_CONFIG_WIN32) && !defined(__CYGWIN__) /* mingw or cygwin */ #if (_FILE_OFFSET_BITS >= 64) return (u64) fseeko64(fp, offset, whence); #else return (u64) fseek(fp, (s32) offset, whence); #endif #elif defined(WIN32) return (u64) _fseeki64(fp, offset, whence); #elif defined(GPAC_CONFIG_LINUX) && !defined(GPAC_ANDROID) return fseeko64(fp, (off64_t) offset, whence); #elif (defined(GPAC_CONFIG_FREEBSD) || defined(GPAC_CONFIG_DARWIN)) return fseeko(fp, (off_t) offset, whence); #else return fseek(fp, (s32) offset, whence); #endif } GF_EXPORT FILE *gf_fopen(const char *file_name, const char *mode) { FILE *res = NULL; #if defined(WIN32) wchar_t *wname; wchar_t *wmode; wname = utf8_to_wcs(file_name); wmode = utf8_to_wcs(mode); if (!wname || !wmode) { if (wname) gf_free(wname); if (wmode) gf_free(wmode); return NULL; } res = _wfsopen(wname, wmode, _SH_DENYNO); gf_free(wname); gf_free(wmode); #elif defined(GPAC_CONFIG_LINUX) && !defined(GPAC_ANDROID) res = fopen64(file_name, mode); #elif (defined(GPAC_CONFIG_FREEBSD) || defined(GPAC_CONFIG_DARWIN)) res = fopen(file_name, mode); #else res = fopen(file_name, mode); #endif if (res) { gpac_file_handles++; GF_LOG(GF_LOG_DEBUG, GF_LOG_CORE, ("[Core] file %s opened in mode %s - %d file handles\n", file_name, mode, gpac_file_handles)); } else { if (strchr(mode, 'w') || strchr(mode, 'a')) { #if defined(WIN32) u32 err = GetLastError(); GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] system failure for file opening of %s in mode %s: 0x%08x\n", file_name, mode, err)); #else GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("[Core] system failure for file opening of %s in mode %s: %d\n", file_name, mode, errno)); #endif } } return res; } GF_EXPORT s32 gf_fclose(FILE *file) { if (file) { assert(gpac_file_handles); gpac_file_handles--; } return fclose(file); } #if (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && ! defined(_GNU_SOURCE) && !defined(WIN32) #define HAVE_STRERROR_R 1 #endif GF_EXPORT size_t gf_fread(void *ptr, size_t size, size_t nmemb, FILE *stream) { return fread(ptr, size, nmemb, stream); } GF_EXPORT size_t gf_fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream) { size_t result = fwrite(ptr, size, nmemb, stream); if (result != nmemb) { #ifdef _WIN32_WCE GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Error writing data: %d blocks to write but %d blocks written\n", nmemb, result)); #else #if defined WIN32 && !defined(GPAC_CONFIG_WIN32) errno_t errno_save; _get_errno(&errno_save); #else int errno_save = errno; #endif //if (errno_save!=0) { #ifdef HAVE_STRERROR_R #define ERRSTR_BUF_SIZE 256 char errstr[ERRSTR_BUF_SIZE]; if(strerror_r(errno_save, errstr, ERRSTR_BUF_SIZE) != 0) { strerror_r(0, errstr, ERRSTR_BUF_SIZE); } #else char *errstr = (char*)strerror(errno_save); #endif GF_LOG(GF_LOG_ERROR, GF_LOG_CORE, ("Error writing data (%s): %d blocks to write but %d blocks written\n", errstr, nmemb, result)); } #endif } return result; }
/* * @implemented */ BOOL WINAPI GetBinaryTypeW ( LPCWSTR lpApplicationName, LPDWORD lpBinaryType ) { HANDLE hFile; DWORD BinType; if(!lpApplicationName || !lpBinaryType) { SetLastError(ERROR_INVALID_PARAMETER); return FALSE; } hFile = CreateFileW(lpApplicationName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0); if(hFile == INVALID_HANDLE_VALUE) { return FALSE; } BinType = InternalGetBinaryType(hFile); CloseHandle(hFile); switch(BinType) { case BINARY_UNKNOWN: { WCHAR *dot; /* * guess from filename */ if(!(dot = wcsrchr(lpApplicationName, L'.'))) { return FALSE; } if(!lstrcmpiW(dot, L".COM")) { *lpBinaryType = SCS_DOS_BINARY; return TRUE; } if(!lstrcmpiW(dot, L".PIF")) { *lpBinaryType = SCS_PIF_BINARY; return TRUE; } return FALSE; } case BINARY_PE_EXE32: case BINARY_PE_DLL32: { *lpBinaryType = SCS_32BIT_BINARY; return TRUE; } case BINARY_PE_EXE64: case BINARY_PE_DLL64: { *lpBinaryType = SCS_64BIT_BINARY; return TRUE; } case BINARY_WIN16: { *lpBinaryType = SCS_WOW_BINARY; return TRUE; } case BINARY_OS216: { *lpBinaryType = SCS_OS216_BINARY; return TRUE; } case BINARY_DOS: { *lpBinaryType = SCS_DOS_BINARY; return TRUE; } case BINARY_UNIX_EXE: case BINARY_UNIX_LIB: { return FALSE; } } DPRINT1("Invalid binary type returned!\n", BinType); return FALSE; }
// Function checks, if we need drop first and last quotation marks // Example: ""7z.exe" /?" // Using cmd.exe rules bool IsNeedDequote(LPCWSTR asCmdLine, bool abFromCmdCK, LPCWSTR* rsEndQuote/*=NULL*/) { if (rsEndQuote) *rsEndQuote = NULL; if (!asCmdLine) return false; bool bDeQu = false; LPCWSTR pszQE, pszSP; if (asCmdLine[0] == L'"') { bDeQu = (asCmdLine[1] == L'"'); // Всегда - нельзя. Иначе парсинг строки запуска некорректно идет // L"\"C:\\ConEmu\\ConEmuC64.exe\" /PARENTFARPID=1 /C \"C:\\GIT\\cmdw\\ad.cmd CE12.sln & ci -m \"Solution debug build properties\"\"" if (!bDeQu) { size_t nLen = lstrlen(asCmdLine); if (abFromCmdCK) { bDeQu = ((asCmdLine[nLen-1] == L'"') && (asCmdLine[nLen-2] == L'"')); } if (!bDeQu && (asCmdLine[nLen-1] == L'"')) { pszSP = wcschr(asCmdLine+1, L' '); pszQE = wcschr(asCmdLine+1, L'"'); if (pszSP && pszQE && (pszSP < pszQE) && ((pszSP - asCmdLine) < MAX_PATH)) { CmdArg lsTmp; lsTmp.Set(asCmdLine+1, pszSP-asCmdLine-1); bDeQu = (IsFilePath(lsTmp, true) && IsExecutable(lsTmp)); } } } } if (!bDeQu) return false; // Don't dequote? pszQE = wcsrchr(asCmdLine+2, L'"'); if (!pszQE) return false; #if 0 LPCWSTR pszQ1 = wcschr(asCmdLine+2, L'"'); if (!pszQ1) return false; LPCWSTR pszQE = wcsrchr(pszQ1, L'"'); // Only TWO quotes in asCmdLine? if (pszQE == pszQ1) { // Doesn't contains special symbols? if (!wcspbrk(asCmdLine+1, L"&<>()@^|")) { // Must contains spaces (doubt?) if (wcschr(asCmdLine+1, L' ')) { // Cmd also checks this for executable file name. Skip this check? return false; } } } #endif // Well, we get here _ASSERTE(asCmdLine[0]==L'"' && pszQE && *pszQE==L'"' && !wcschr(pszQE+1,L'"')); // Dequote it! if (rsEndQuote) *rsEndQuote = pszQE; return true; }