std::string GetOS()
{
#if defined(WIN32)
return "Microsoft Windows\n" +
GetOSDisplayString() + "\n" +
GetHardwareInfoString();
#else
struct utsname info;
if (uname(&info) == 0) {
return std::string(info.sysname) + " "
+ info.release + " "
+ info.version + " "
+ info.machine;
} else {
#if defined(__linux__)
return "Linux";
#elif defined(__FreeBSD__)
return "FreeBSD";
#elif defined(__APPLE__)
return "Mac OS X";
#else
#warning improve this
return "unknown OS";
#endif
}
#endif
}
void GetAgentInfo(AgentSystemInfo *info)
{
SYSTEM_INFO siSysInfo;
// get cpu info
GetSystemInfo(&siSysInfo);
switch(siSysInfo.wProcessorArchitecture)
{
case PROCESSOR_ARCHITECTURE_AMD64:
info->cpu = "x64";
break;
case PROCESSOR_ARCHITECTURE_IA64:
info->cpu = "IA64";
break;
case PROCESSOR_ARCHITECTURE_INTEL:
info->cpu = "x86";
break;
default:
info->cpu = "Unknown";
break;
}
// get dns hostname
DWORD dwSize = 0;
// first get the buffer size
GetComputerNameEx(ComputerNameDnsFullyQualified, NULL, &dwSize);
char *name_buf = new char[dwSize + 1];
// second get the host name, dns full qualified
if (!GetComputerNameEx(ComputerNameDnsFullyQualified, name_buf, &dwSize))
{
Log::Error("Get dns fully qualified name failed, exit now!");
exit(-1);
info->hostname = "Unknown";
}
else
{
info->hostname = string(name_buf, dwSize);
}
delete [] name_buf;
info->system = "Windows";
char buf[255];
// get release and version
OSVERSIONINFO osvi;
ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&osvi);
sprintf(buf, "%d.%d", osvi.dwMajorVersion, osvi.dwMinorVersion);
info->release = buf;
TCHAR szOS[BUFSIZE];
if( GetOSDisplayString(szOS))
{
info->version = szOS;
}
else
{
info->version = "Unknown";
}
info->agent_version = AGENT_VERSION;
}
VOID print_os()
{
TCHAR szOS[MAX_PATH] = _T("");
if (GetOSDisplayString(szOS))
{
_tcscpy_s(szOS, MAX_PATH, szOS);
_tprintf(_T("\n%s\n"), szOS);
}
}
std::string system_info_windows_version()
{
TCHAR szOS[BUFSIZE] = {0};
if( GetOSDisplayString( szOS ) )
{
std::string ret(szOS);
return ret;
}
return "undetected";
}
std::string GetOS()
{
#if defined(WIN32)
return "Microsoft Windows\n" +
GetOSDisplayString() + "\n" +
GetHardwareInfoString();
#elif defined(__linux__)
return "Linux";
#elif defined(__FreeBSD__)
return "FreeBSD";
#elif defined(__APPLE__)
return "Mac OS X";
#else
return "unknown OS";
#endif
}
BOOL CJabberProto::OnIqRequestVersion(HXML, CJabberIqInfo *pInfo)
{
if (!pInfo->GetFrom())
return TRUE;
if (!m_options.AllowVersionRequests)
return FALSE;
XmlNodeIq iq(_T("result"), pInfo);
HXML query = iq << XQUERY(JABBER_FEAT_VERSION);
query << XCHILD(_T("name"), _T("Miranda NG Jabber"));
query << XCHILD(_T("version"), szCoreVersion);
if (m_options.ShowOSVersion) {
TCHAR os[256] = { 0 };
if (!GetOSDisplayString(os, _countof(os)))
mir_tstrncpy(os, _T("Microsoft Windows"), _countof(os));
query << XCHILD(_T("os"), os);
}
m_ThreadInfo->send(iq);
return TRUE;
}
HRESULT __stdcall vcInitialize()
{
GetTempPath(MAX_PATH, g_szTempPath);
PathRemoveBackslash(g_szTempPath);
GetModuleFileName(NULL, g_szModulePath, MAX_PATH);
PathRemoveFileSpec(g_szModulePath);
CreateLogFile();
GetOSDisplayString();
GetSystemInformations();
InitGdiplus();
InitCommonResource();
InitHSBControlWindow();
ffmpeg_init();
LoadProfiles();
InitMediaMananger();
InitVideoPlayer();
InitVideoRender();
StringCchCopy(g_merge_info.m_Name, 256, L"merged");
if (LoadOptions() != S_OK)
{
SHGetFolderPath(NULL, CSIDL_MYVIDEO | CSIDL_FLAG_CREATE, NULL, 0, g_opt.m_OutputPath);
g_opt.m_Parallel = g_cpu_count;
g_opt.m_FillColor2 = 0xFFFFFFFF;
}
if (LoadProfileSettings() != S_OK)
{
ZeroMemory(&g_ProfileSettings, sizeof(g_ProfileSettings));
GetDefaultProfileSetting1(g_ProfileSettings, GROUP_VIDEO);
}
CopyProfileSettings();
return S_OK;
}
DWORD EGLExceptionHandler (DWORD exceptionCode, LPEXCEPTION_POINTERS exceptionInfo)
{
context = *exceptionInfo->ContextRecord;
// Show the mouse cursor
ShowCursor (TRUE);
// Continue searching?
#ifdef _DEBUG
if (MessageBoxA (NULL, "An unhandled exception occured in CleanCode!\n\nThis version was built with debug information. Do you have a debugger you can attach? If so, do this now, then click Yes, otherwise click No.", "Unhandled Exception", MB_ICONERROR|MB_YESNO) == IDYES)
return EXCEPTION_CONTINUE_SEARCH;
#endif
// Load needed libraries and get the location of the needed functions
hDbgHelp = LoadLibraryA ("DBGHELP");
if (!hDbgHelp)
{
MessageBoxA (NULL, APP_FULLNAME " has encountered an unhandled exception and must be terminated. No crash report could be generated since " APP_FULLNAME " failed to load DBGHELP.DLL. Please obtain DBGHELP.DLL and place it in your Quake II directory to enable crash dump generation.", "Unhandled Exception", MB_OK | MB_ICONEXCLAMATION);
return EXCEPTION_CONTINUE_SEARCH;
}
hVersion = LoadLibraryA ("VERSION");
if (hVersion)
{
fnVerQueryValue = (VERQUERYVALUE)GetProcAddress (hVersion, "VerQueryValueA");
fnGetFileVersionInfo = (GETFILEVERSIONINFO)GetProcAddress (hVersion, "GetFileVersionInfoA");
fnGetFileVersionInfoSize = (GETFILEVERSIONINFOSIZE)GetProcAddress (hVersion, "GetFileVersionInfoSizeA");
}
fnEnumerateLoadedModules64 = (ENUMERATELOADEDMODULES64)GetProcAddress (hDbgHelp, "EnumerateLoadedModules64");
fnSymSetOptions = (SYMSETOPTIONS)GetProcAddress (hDbgHelp, "SymSetOptions");
fnSymInitialize = (SYMINITIALIZE)GetProcAddress (hDbgHelp, "SymInitialize");
fnSymFunctionTableAccess64 = (SYMFUNCTIONTABLEACCESS64)GetProcAddress (hDbgHelp, "SymFunctionTableAccess64");
fnSymGetModuleBase64 = (SYMGETMODULEBASE64)GetProcAddress (hDbgHelp, "SymGetModuleBase64");
fnStackWalk64 = (STACKWALK64)GetProcAddress (hDbgHelp, "StackWalk64");
fnSymFromAddr = (SYMFROMADDR)GetProcAddress (hDbgHelp, "SymFromAddr");
fnSymCleanup = (SYMCLEANUP)GetProcAddress (hDbgHelp, "SymCleanup");
fnSymGetModuleInfo64 = (SYMGETMODULEINFO64)GetProcAddress (hDbgHelp, "SymGetModuleInfo64");
//fnSymLoadModule64 = (SYMLOADMODULE64)GetProcAddress (hDbgHelp, "SymLoadModule64");
fnMiniDumpWriteDump = (MINIDUMPWRITEDUMP)GetProcAddress (hDbgHelp, "MiniDumpWriteDump");
if (!fnEnumerateLoadedModules64 || !fnSymSetOptions || !fnSymInitialize || !fnSymFunctionTableAccess64
|| !fnSymGetModuleBase64 || !fnStackWalk64 || !fnSymFromAddr || !fnSymCleanup || !fnSymGetModuleInfo64)
// || !fnSymLoadModule64)
{
FreeLibrary (hDbgHelp);
if (hVersion)
FreeLibrary (hVersion);
MessageBoxA (NULL, APP_FULLNAME " has encountered an unhandled exception and must be terminated. No crash report could be generated since " APP_FULLNAME " failed to load DBGHELP.DLL. Please obtain DBGHELP.DLL and place it in your Quake II directory to enable crash dump generation.", "Unhandled Exception", MB_OK | MB_ICONEXCLAMATION);
return EXCEPTION_CONTINUE_SEARCH;
}
// Let the user know
if (MessageBoxA (NULL, APP_FULLNAME " has encountered an unhandled exception and must be terminated. Would you like to generate a crash report?", "Unhandled Exception", MB_ICONEXCLAMATION | MB_YESNO) == IDNO)
{
FreeLibrary (hDbgHelp);
if (hVersion)
FreeLibrary (hVersion);
return EXCEPTION_CONTINUE_SEARCH;
}
// Get the current process
hProcess = GetCurrentProcess();
fnSymSetOptions (SYMOPT_UNDNAME | SYMOPT_FAIL_CRITICAL_ERRORS | SYMOPT_LOAD_ANYTHING);
// Used to determine the directory for dump placement
GetModuleFileNameA (NULL, searchPath, sizeof(searchPath));
tempPointer = strrchr (searchPath, '\\');
if (tempPointer)
*tempPointer = '\0';
// Get the system time
GetSystemTime (&timeInfo);
// Find the next filename to use for this dump
sint32 dumpNum = 1;
for (; ; dumpNum++)
{
Q_snprintfz (reportPath, sizeof(reportPath), "%s\\CCCrashLog%.4d-%.2d-%.2d_%d.txt", searchPath, timeInfo.wYear, timeInfo.wMonth, timeInfo.wDay, dumpNum);
if (Sys_FileLength (reportPath) == -1)
break;
}
// Open the report dump file
fhReport = fopen (reportPath, "wb");
if (!fhReport)
{
FreeLibrary (hDbgHelp);
if (hVersion)
FreeLibrary (hVersion);
return EXCEPTION_CONTINUE_SEARCH;
}
// Initialize symbols
fnSymInitialize (hProcess, searchPath, TRUE);
#ifdef _M_AMD64
InstructionPtr = context.Rip;
frame.AddrPC.Offset = InstructionPtr;
frame.AddrFrame.Offset = context.Rbp;
frame.AddrPC.Offset = context.Rsp;
#else
InstructionPtr = context.Eip;
frame.AddrPC.Offset = InstructionPtr;
frame.AddrFrame.Offset = context.Ebp;
frame.AddrStack.Offset = context.Esp;
#endif
frame.AddrFrame.Mode = AddrModeFlat;
frame.AddrPC.Mode = AddrModeFlat;
frame.AddrStack.Mode = AddrModeFlat;
symInfo = (SYMBOL_INFO*)LocalAlloc (LPTR, sizeof(*symInfo) + 128);
symInfo->SizeOfStruct = sizeof(SYMBOL_INFO);
symInfo->MaxNameLen = 128;
fnOffset = 0;
// Get OS info
Mem_Zero (&osInfo, sizeof(osInfo));
osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
if (!GetVersionEx ((OSVERSIONINFO *)&osInfo))
{
osInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx ((OSVERSIONINFO *)&osInfo);
}
// Find out which module threw the exception
Q_strncpyz (szModuleName, "<unknown>", sizeof(szModuleName));
fnEnumerateLoadedModules64 (hProcess, (PENUMLOADED_MODULES_CALLBACK64)EnumerateLoadedModulesProcInfo, (VOID *)InstructionPtr);
Q_strlwr (szModuleName);
if (strstr (szModuleName, "gamex86"))
{
upMessage =
"CleanCode's Gamex86 seems to be the root problem.\r\n"
"If this is not base CleanCode, send the report to the mod author,\r\n"
"otherwise send it to Paril (see the log .txt for more info)\r\n";
#ifdef USE_CURL
upload = false;
#endif
}
else
{
upMessage =
"Unable to detect where the exception occured!\r\n";
#ifdef USE_CURL
upload = true;
#endif
}
// Write out the report to file
fprintf (fhReport,
APP_FULLNAME " encountered an unhandled exception and was terminated. If you are\r\n"
"able to reproduce this crash, please submit the crash report when prompted, or email\r\n"
"the file to Paril or any CleanCode project member. Goto http://code.google.com/p/cleancodequake2 and click on\r\n"
"Issues, and file a bug report, or email [email protected] with the report.\r\n"
"\r\n"
"*** PLEASE MAKE SURE THAT YOU ARE USING THE LATEST VERSION OF CLEANCODE BEFORE SUBMITTING ***\r\nYour Cleancode Version: "CLEANCODE_VERSION_PRINT"\r\n", CLEANCODE_VERSION_PRINT_ARGS);
fprintf (fhReport, "\r\n");
// Windows information
fprintf (fhReport, "Windows information:\r\n");
fprintf (fhReport, "--------------------------------------------------\r\n");
fprintf (fhReport, "String: %s\r\n", GetOSDisplayString().CString());
fprintf (fhReport, "Version: %d.%d\r\n", osInfo.dwMajorVersion, osInfo.dwMinorVersion);
fprintf (fhReport, "Build: %d\r\n", osInfo.dwBuildNumber);
fprintf (fhReport, "Service Pack: %s\r\n", osInfo.szCSDVersion[0] ? osInfo.szCSDVersion : "none");
fprintf (fhReport, "\r\n");
// Exception information
fprintf (fhReport, "Exception information:\r\n");
fprintf (fhReport, "--------------------------------------------------\r\n");
fprintf (fhReport, "Code: "HEX_VALUE_32"\r\n", exceptionCode);
fprintf (fhReport, "Address: "HEX_VALUE_64"\r\n", InstructionPtr);
fprintf (fhReport, "Module: %s\r\n", szModuleName);
fprintf (fhReport, "\r\n");
// Symbol information
fprintf (fhReport, "Symbol information:\r\n");
fprintf (fhReport, "Name Symbol Type\r\n");
fprintf (fhReport, "-----------------------------------------------------------------------\r\n");
fnEnumerateLoadedModules64 (hProcess, (PENUMLOADED_MODULES_CALLBACK64)EEnumerateLoadedModulesProcSymInfoHeap::EnumerateLoadedModulesProcSymInfo, (VOID *)fhReport);
fprintf (fhReport, "\r\n");
// Loaded modules
fprintf (fhReport, "Loaded modules:\r\n");
fprintf (fhReport, "--------------------------------------------------\r\n");
fnEnumerateLoadedModules64 (hProcess, (PENUMLOADED_MODULES_CALLBACK64)EnumerateLoadedModulesProcDump, (VOID *)fhReport);
fprintf (fhReport, "\r\n");
// Stack trace
fprintf (fhReport, "Stack trace:\r\n");
fprintf (fhReport, "--------------------------------------------------\r\n");
fprintf (fhReport, "Stack EIP Arg0 Arg1 Arg2 Arg3 Address\r\n");
while (fnStackWalk64 (IMAGE_FILE_MACHINE_I386, hProcess, GetCurrentThread(), &frame, &context, NULL, (PFUNCTION_TABLE_ACCESS_ROUTINE64)fnSymFunctionTableAccess64, (PGET_MODULE_BASE_ROUTINE64)fnSymGetModuleBase64, NULL))
{
Q_strncpyz (szModuleName, "<unknown>", sizeof(szModuleName));
fnEnumerateLoadedModules64 (hProcess, (PENUMLOADED_MODULES_CALLBACK64)EnumerateLoadedModulesProcInfo, (VOID *)(DWORD)frame.AddrPC.Offset);
tempPointer = strrchr (szModuleName, '\\');
if (tempPointer)
tempPointer++;
else
tempPointer = szModuleName;
fprintf (fhReport, ""HEX_VALUE_64" "HEX_VALUE_64" "HEX_VALUE_32" "HEX_VALUE_32" "HEX_VALUE_32" "HEX_VALUE_32" %-20s ! ",
frame.AddrStack.Offset, frame.AddrPC.Offset, (DWORD)frame.Params[0], (DWORD)frame.Params[1], (DWORD)frame.Params[2], (DWORD)frame.Params[3], tempPointer);
if (fnSymFromAddr (hProcess, frame.AddrPC.Offset, &fnOffset, symInfo) && !(symInfo->Flags & SYMFLAG_EXPORT))
fprintf (fhReport, "%-24s + "HEX_VALUE_64" %lu\r\n", symInfo->Name, fnOffset, symInfo->Tag);
else
fprintf (fhReport, ""HEX_VALUE_64"\r\n", frame.AddrPC.Offset);
}
fprintf (fhReport, "\r\n");
// Write a minidump
if (fnMiniDumpWriteDump)
{
HANDLE hFile;
//GetTempPath (sizeof(dumpPath)-16, dumpPath);
Q_snprintfz (dumpPath, sizeof(dumpPath), "%s\\CCCrashLog%.4d-%.2d-%.2d_%d.dmp", searchPath, timeInfo.wYear, timeInfo.wMonth, timeInfo.wDay, dumpNum);
hFile = CreateFileA (dumpPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile != INVALID_HANDLE_VALUE)
{
miniInfo.ClientPointers = TRUE;
miniInfo.ExceptionPointers = exceptionInfo;
miniInfo.ThreadId = GetCurrentThreadId ();
if (fnMiniDumpWriteDump (hProcess, GetCurrentProcessId(), hFile, (MINIDUMP_TYPE)(MiniDumpWithIndirectlyReferencedMemory|MiniDumpWithDataSegs), &miniInfo, NULL, NULL))
{
CloseHandle (hFile);
FILE *fh;
#ifdef USE_GZ
CHAR zPath[MAX_PATH];
#endif
fh = fopen (dumpPath, "rb");
if (fh)
#ifdef USE_GZ
{
gzFile gz;
Q_snprintfz (zPath, sizeof(zPath)-1, "%s\\CCCrashLog%.4d-%.2d-%.2d_%d.dmp.gz", searchPath, timeInfo.wYear, timeInfo.wMonth, timeInfo.wDay, dumpNum);
gz = gzopen (zPath, "wb");
if (gz)
{
size_t len;
while ((len = fread (gzBuff, 1, sizeof(gzBuff), fh)) > 0)
gzwrite (gz, gzBuff, (uint32)len);
gzclose (gz);
#endif
fclose (fh);
#ifdef USE_GZ
}
}
#endif
#ifdef USE_GZ
DeleteFileA (dumpPath);
Q_strncpyz (dumpPath, zPath, sizeof(dumpPath));
#endif
fprintf (fhReport, "A "
#ifdef USE_GZ
"minidump"
#else
"dump"
#endif
" was saved to %s.\r\nPlease include this file when posting a crash report.\r\n", dumpPath);
}
else
{
CloseHandle (hFile);
DeleteFileA (dumpPath);
}
}
}
else
fprintf (fhReport, "A minidump could not be created. Minidumps are only available on Windows XP or later.\r\n");
// Done writing reports
fclose (fhReport);
LocalFree (symInfo);
fnSymCleanup (hProcess);
// Let the client know
String temp = String::Format("Report written to: %s\r\nMini-dump written to %s\r\nPlease include both files if you submit manually!\r\n", reportPath, dumpPath);
MessageBoxA (NULL, temp.CString(), "Unhandled Exception", MB_ICONEXCLAMATION | MB_OK);
#ifdef USE_CURL
if (upload)
{
ret = MessageBox (NULL, "Would you like to automatically upload this crash report for analysis?\nPlease do not submit multiple reports of the same crash as this will only delay processing.", "Unhandled Exception", MB_ICONQUESTION | MB_YESNO | MB_DEFBUTTON2);
if (ret == IDYES)
EGLUploadCrashDump (dumpPath, reportPath);
else
MessageBox (NULL, "You have chosen to manually upload the crash report.\nPlease include BOTH the crash log and mini-dump when you post it on the EGL forums!\n", "Submit manually", MB_ICONEXCLAMATION|MB_OK);
}
else
#endif
MessageBoxA (NULL, upMessage, "Unhandled Exception", MB_OK|MB_ICONEXCLAMATION);
// Done
FreeLibrary (hDbgHelp);
if (hVersion)
FreeLibrary (hVersion);
return EXCEPTION_EXECUTE_HANDLER;
}
void PrintVersionInfo(CMString& buffer, unsigned flags)
{
GetProcessorString(buffer);
buffer.Append(TEXT("\r\n"));
GetFreeMemoryString(buffer);
buffer.Append(TEXT("\r\n"));
GetOSDisplayString(buffer);
buffer.Append(TEXT("\r\n"));
GetInternetExplorerVersion(buffer);
buffer.Append(TEXT("\r\n"));
GetAdminString(buffer);
buffer.Append(TEXT("\r\n"));
GetLanguageString(buffer);
buffer.Append(TEXT("\r\n"));
TCHAR *profpathfull = Utils_ReplaceVarsT(profpath);
if (flags & VI_FLAG_PRNVAR) {
GetFreeDiskString(profpathfull, buffer);
buffer.Append(TEXT("\r\n"));
}
buffer.AppendFormat(TEXT("\r\nMiranda NG Version: %s"), vertxt);
GetWow64String(buffer);
buffer.Append(TEXT("\r\n"));
TCHAR path[MAX_PATH], mirtime[30];
GetModuleFileName(NULL, path, MAX_PATH);
GetLastWriteTime(path, mirtime, 30);
buffer.AppendFormat(TEXT("Build time: %s\r\n"), mirtime);
TCHAR profpn[MAX_PATH];
mir_sntprintf(profpn, _countof(profpn), TEXT("%s\\%s"), profpathfull, profname);
buffer.AppendFormat(TEXT("Profile: %s\r\n"), profpn);
if (flags & VI_FLAG_PRNVAR) {
WIN32_FIND_DATA FindFileData;
HANDLE hFind = FindFirstFile(profpn, &FindFileData);
if (hFind != INVALID_HANDLE_VALUE) {
FindClose(hFind);
unsigned __int64 fsize = (unsigned __int64)FindFileData.nFileSizeHigh << 32 | FindFileData.nFileSizeLow;
buffer.AppendFormat(TEXT("Profile size: %I64u Bytes\r\n"), fsize),
GetLastWriteTime(&FindFileData.ftCreationTime, mirtime, 30);
buffer.AppendFormat(TEXT("Profile creation date: %s\r\n"), mirtime);
}
}
mir_free(profpathfull);
GetLanguagePackString(buffer);
buffer.Append(TEXT("\r\n"));
// buffer.AppendFormat(TEXT("Nightly: %s\r\n"), _tcsstr(vertxt, TEXT("alpha")) ? TEXT("Yes") : TEXT("No"));
// buffer.AppendFormat(TEXT("Unicode: %s\r\n"), _tcsstr(vertxt, TEXT("Unicode")) ? TEXT("Yes") : TEXT("No"));
GetPluginsString(buffer, flags);
if (flags & VI_FLAG_WEATHER) {
buffer.AppendFormat(TEXT("\r\n%sWeather ini files:%s\r\n-------------------------------------------------------------------------------\r\n"),
(flags & VI_FLAG_FORMAT) ? TEXT("[b]") : TEXT(""),
(flags & VI_FLAG_FORMAT) ? TEXT("[/b]") : TEXT(""));
GetWeatherStrings(buffer, flags);
}
if (flags & VI_FLAG_PRNVAR && !servicemode) {
buffer.AppendFormat(TEXT("\r\n%sProtocols and Accounts:%s\r\n-------------------------------------------------------------------------------\r\n"),
(flags & VI_FLAG_FORMAT) ? TEXT("[b]") : TEXT(""),
(flags & VI_FLAG_FORMAT) ? TEXT("[/b]") : TEXT(""));
GetProtocolStrings(buffer);
}
if (flags & VI_FLAG_PRNVAR) {
buffer.AppendFormat(TEXT("\r\n%sIcon Packs:%s\r\n-------------------------------------------------------------------------------\r\n"),
(flags & VI_FLAG_FORMAT) ? TEXT("[b]") : TEXT(""),
(flags & VI_FLAG_FORMAT) ? TEXT("[/b]") : TEXT(""));
GetIconStrings(buffer);
}
if (flags & VI_FLAG_PRNDLL) {
__try {
buffer.Append(TEXT("\r\nLoaded Modules:\r\n-------------------------------------------------------------------------------\r\n"));
EnumerateLoadedModules64(GetCurrentProcess(), LoadedModules64, &buffer);
}
__except (EXCEPTION_EXECUTE_HANDLER) {}
}
/// \brief Initiate the ultracopier event dispatcher and check if no other session is running
EventDispatcher::EventDispatcher()
{
qRegisterMetaType<QList<Ultracopier::ReturnActionOnCopyList> >("QList<Ultracopier::ReturnActionOnCopyList>");
qRegisterMetaType<QList<Ultracopier::ProgressionItem> >("QList<Ultracopier::ProgressionItem>");
qRegisterMetaType<Ultracopier::EngineActionInProgress>("Ultracopier::EngineActionInProgress");
qRegisterMetaType<QList<QUrl> >("QList<QUrl>");
qRegisterMetaType<Ultracopier::ItemOfCopyList>("Ultracopier::ItemOfCopyList");
#ifdef ULTRACOPIER_CGMINER
qRegisterMetaType<QProcess::ExitStatus>("QProcess::ExitStatus");
qRegisterMetaType<QProcess::ProcessError>("QProcess::ProcessError");
#endif
copyServer=new CopyListener(&optionDialog);
connect(&localListener, &LocalListener::cli, &cliParser, &CliParser::cli,Qt::QueuedConnection);
connect(ThemesManager::themesManager, &ThemesManager::newThemeOptions, &optionDialog, &OptionDialog::newThemeOptions);
connect(&cliParser, &CliParser::newCopyWithoutDestination, copyServer, &CopyListener::copyWithoutDestination);
connect(&cliParser, &CliParser::newCopy, copyServer, &CopyListener::copy);
connect(&cliParser, &CliParser::newMoveWithoutDestination, copyServer, &CopyListener::moveWithoutDestination);
connect(&cliParser, &CliParser::newMove, copyServer, &CopyListener::move);
connect(copyServer, &CopyListener::newClientList, &optionDialog, &OptionDialog::newClientList);
#ifdef ULTRACOPIER_PLUGIN_IMPORT_SUPPORT
connect(&cliParser, &CliParser::tryLoadPlugin, PluginsManager::pluginsManager, &PluginsManager::tryLoadPlugin);
#endif
copyMoveEventIdIndex=0;
backgroundIcon=NULL;
stopIt=false;
#ifndef ULTRACOPIER_VERSION_PORTABLE
sessionloader=new SessionLoader(&optionDialog);
#endif
copyEngineList=new CopyEngineManager(&optionDialog);
core=new Core(copyEngineList);
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Notice,"start");
//show the ultracopier information
#if defined(Q_OS_WIN32) || defined(Q_OS_MAC)
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Information,QString("Windows version: %1").arg(GetOSDisplayString()));
#endif
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Information,QString("ULTRACOPIER_VERSION: ")+ULTRACOPIER_VERSION);
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Information,QString("Qt version: %1 (%2)").arg(qVersion()).arg(QT_VERSION));
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Information,QString("ULTRACOPIER_PLATFORM_NAME: ")+ULTRACOPIER_PLATFORM_NAME);
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Information,QString("Application path: %1 (%2)").arg(QCoreApplication::applicationFilePath()).arg(QCoreApplication::applicationPid()));
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Information,COMPILERINFO);
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Information,QString("Local socket: ")+ExtraSocket::pathSocket(ULTRACOPIER_SOCKETNAME));
#ifdef ULTRACOPIER_CGMINER
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Information,QString("With cgminer"));
#endif
#if defined(ULTRACOPIER_DEBUG) && defined(ULTRACOPIER_PLUGIN_ALL_IN_ONE)
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Information,QString("Version as all in one"));
QObjectList objectList=QPluginLoader::staticInstances();
int index=0;
while(index<objectList.size())
{
ULTRACOPIER_DEBUGCONSOLE(Ultracopier::DebugLevel_Information,QString("static plugin: %1").arg(objectList.at(index)->metaObject()->className()));
index++;
}
#endif
//To lunch some initialization after QApplication::exec() to quit eventually
lunchInitFunction.setInterval(0);
lunchInitFunction.setSingleShot(true);
connect(&lunchInitFunction,&QTimer::timeout,this,&EventDispatcher::initFunction,Qt::QueuedConnection);
lunchInitFunction.start();
if(OptionEngine::optionEngine->getOptionValue("Ultracopier","Last_version_used")!=QVariant("na") && OptionEngine::optionEngine->getOptionValue("Ultracopier","Last_version_used")!=QVariant(ULTRACOPIER_VERSION))
{
//then ultracopier have been updated
}
OptionEngine::optionEngine->setOptionValue("Ultracopier","Last_version_used",QVariant(ULTRACOPIER_VERSION));
int a=OptionEngine::optionEngine->getOptionValue("Ultracopier","ActionOnManualOpen").toInt();
if(a<0 || a>2)
OptionEngine::optionEngine->setOptionValue("Ultracopier","ActionOnManualOpen",QVariant(1));
a=OptionEngine::optionEngine->getOptionValue("Ultracopier","GroupWindowWhen").toInt();
if(a<0 || a>5)
OptionEngine::optionEngine->setOptionValue("Ultracopier","GroupWindowWhen",QVariant(0));
connect(&cliParser, &CliParser::newTransferList,core, &Core::newTransferList);
}
BOOL CJabberClientCapsManager::HandleInfoRequest(HXML, CJabberIqInfo *pInfo, const TCHAR *szNode)
{
int i;
JabberCapsBits jcb = 0;
if (szNode) {
for (i=0; g_JabberFeatCapPairsExt[i].szFeature; i++) {
if (!g_JabberFeatCapPairsExt[i].Valid())
continue;
TCHAR szExtCap[ 512 ];
mir_sntprintf(szExtCap, SIZEOF(szExtCap), _T("%s#%s"), JABBER_CAPS_MIRANDA_NODE, g_JabberFeatCapPairsExt[i].szFeature);
if (!_tcscmp(szNode, szExtCap)) {
jcb = g_JabberFeatCapPairsExt[i].jcbCap;
break;
}
}
// check features registered through IJabberNetInterface::RegisterFeature() and IJabberNetInterface::AddFeatures()
for (i=0; i < ppro->m_lstJabberFeatCapPairsDynamic.getCount(); i++) {
TCHAR szExtCap[ 512 ];
mir_sntprintf(szExtCap, SIZEOF(szExtCap), _T("%s#%s"), JABBER_CAPS_MIRANDA_NODE, ppro->m_lstJabberFeatCapPairsDynamic[i]->szExt);
if (!_tcscmp(szNode, szExtCap)) {
jcb = ppro->m_lstJabberFeatCapPairsDynamic[i]->jcbCap;
break;
}
}
// unknown node, not XEP-0115 request
if (!jcb)
return FALSE;
}
else {
jcb = JABBER_CAPS_MIRANDA_ALL;
for (i=0; i < ppro->m_lstJabberFeatCapPairsDynamic.getCount(); i++)
jcb |= ppro->m_lstJabberFeatCapPairsDynamic[i]->jcbCap;
}
if (!ppro->m_options.AllowVersionRequests)
jcb &= ~JABBER_CAPS_VERSION;
XmlNodeIq iq(_T("result"), pInfo);
HXML query = iq << XQUERY(JABBER_FEAT_DISCO_INFO);
if (szNode)
query << XATTR(_T("node"), szNode);
query << XCHILD(_T("identity")) << XATTR(_T("category"), _T("client"))
<< XATTR(_T("type"), _T("pc")) << XATTR(_T("name"), _T("Miranda"));
for (i=0; g_JabberFeatCapPairs[i].szFeature; i++)
if (jcb & g_JabberFeatCapPairs[i].jcbCap)
query << XCHILD(_T("feature")) << XATTR(_T("var"), g_JabberFeatCapPairs[i].szFeature);
for (i=0; i < ppro->m_lstJabberFeatCapPairsDynamic.getCount(); i++)
if (jcb & ppro->m_lstJabberFeatCapPairsDynamic[i]->jcbCap)
query << XCHILD(_T("feature")) << XATTR(_T("var"), ppro->m_lstJabberFeatCapPairsDynamic[i]->szFeature);
if (ppro->m_options.AllowVersionRequests && !szNode) {
TCHAR szOsBuffer[256] = {0};
TCHAR *os = szOsBuffer;
if (ppro->m_options.ShowOSVersion) {
if (!GetOSDisplayString(szOsBuffer, SIZEOF(szOsBuffer)))
lstrcpyn(szOsBuffer, _T(""), SIZEOF(szOsBuffer));
else {
TCHAR *szOsWindows = _T("Microsoft Windows");
size_t nOsWindowsLength = _tcslen(szOsWindows);
if (!_tcsnicmp(szOsBuffer, szOsWindows, nOsWindowsLength))
os += nOsWindowsLength + 1;
}
}
HXML form = query << XCHILDNS(_T("x"), JABBER_FEAT_DATA_FORMS) << XATTR(_T("type"), _T("result"));
form << XCHILD(_T("field")) << XATTR(_T("var"), _T("FORM_TYPE")) << XATTR(_T("type"), _T("hidden"))
<< XCHILD(_T("value"), _T("urn:xmpp:dataforms:softwareinfo"));
if (ppro->m_options.ShowOSVersion) {
form << XCHILD(_T("field")) << XATTR(_T("var"), _T("os")) << XCHILD(_T("value"), _T("Microsoft Windows"));
form << XCHILD(_T("field")) << XATTR(_T("var"), _T("os_version")) << XCHILD(_T("value"), os);
}
form << XCHILD(_T("field")) << XATTR(_T("var"), _T("software")) << XCHILD(_T("value"), _T("Miranda NG Jabber Protocol"));
form << XCHILD(_T("field")) << XATTR(_T("var"), _T("software_version")) << XCHILD(_T("value"), _T(__VERSION_STRING_DOTS));
form << XCHILD(_T("field")) << XATTR(_T("var"), _T("x-miranda-core-version")) << XCHILD(_T("value"), szCoreVersion);
}
ppro->m_ThreadInfo->send(iq);
return TRUE;
}