void CFunctionProfiler::GetRuntimeFullMethodSignature(FunctionID funcID, COR_PRF_FRAME_INFO func, std::wstring& methodName)
{
    ClassID funcClass;
    CComPtr<IMetaDataImport2> metaDataImport2;
	mdToken funcToken;
	GetClassIDForFunctionID(funcID, func, funcClass, funcToken, &metaDataImport2);

    std::wstring className;
    CFunctionProfiler::g_pProfiler->GetRuntimeClassSignature(funcClass, className);

    CFunctionProfiler::g_pProfiler->GetRuntimeMethodSignature(funcID, NULL, metaDataImport2, methodName);
        
    methodName.insert(0, L"::");
    methodName.insert(0, className);
}
Exemple #2
0
std::wstring getAppDataPath(std::wstring extra)
{
#ifdef NIX
	#if defined(USE_XDG_DIRS)
		std::string configPath = getenv("XDG_CONFIG_HOME");
		configPath.append("/desura");
	#elif defined(USE_SINGLE_HOME_DIR)
		std::string configPath = getenv("HOME");
		configPath.append("/.desura");
	#elif defined(USE_PORTABLE_DIR)
		std::string configPath = UTIL::STRING::toStr(getCurrentDir(L"config"));
	#endif
	
	if (extra.size() > 0)
		extra.insert(0, DIRS_WSTR);
	
	return UTIL::STRING::toWStr(configPath) + extra;
#else
	wchar_t path[MAX_PATH];
	getSystemPath(CSIDL_COMMON_APPDATA, path);

	gcWString out(path);

	out += DIRS_WSTR;
	out += COMMONAPP_PATH_W;

	if (extra.size() > 0)
	{
		out += DIRS_WSTR;
		out += extra;
	}

	return out;
#endif
}
//Get infomation of service
size_t __stdcall GetServiceInfo()
{
//Get service information
	SC_HANDLE SCM = nullptr, Service = nullptr;
	DWORD nResumeHandle = 0;

	if((SCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS)) == nullptr)
		return EXIT_FAILURE;
 
	Service = OpenService(SCM, LOCALSERVERNAME, SERVICE_ALL_ACCESS);
	if(Service == nullptr)
		return EXIT_FAILURE;

	LPQUERY_SERVICE_CONFIG ServicesInfo = (LPQUERY_SERVICE_CONFIG)LocalAlloc(LPTR, PACKET_MAXSIZE*4); //Max buffer of QueryServiceConfig() is 8KB/8192 Bytes.
	if (ServicesInfo == nullptr)
		return EXIT_FAILURE;

	if (QueryServiceConfig(Service, ServicesInfo, PACKET_MAXSIZE*4, &nResumeHandle) == FALSE)
	{
		LocalFree(ServicesInfo);
		return EXIT_FAILURE;
	}

	Path = ServicesInfo->lpBinaryPathName;
	LocalFree(ServicesInfo);

//Path process
	size_t Index = Path.rfind(_T("\\"));
	static const WCHAR wBackslash[] = _T("\\");
	Path.erase(Index + 1, Path.length());

	for (Index = 0;Index < Path.length();Index++)
	{
		if (Path[Index] == _T('\\'))
		{
			Path.insert(Index, wBackslash);
			Index++;
		}
	}

//Get path of error log file and delete the old one
	ErrorLogPath.append(Path);
	ErrorLogPath.append(_T("Error.log"));
	DeleteFile(ErrorLogPath.c_str());
	Parameter.PrintError = true;

//Winsock initialization
	WSADATA WSAData = {0};
	if (WSAStartup(MAKEWORD(2, 2), &WSAData) != 0 || LOBYTE(WSAData.wVersion) != 2 || HIBYTE(WSAData.wVersion) != 2)
	{
		PrintError(Winsock_Error, _T("Winsock initialization failed"), WSAGetLastError(), NULL);

		WSACleanup();
		return EXIT_FAILURE;
	}

	return EXIT_SUCCESS;
}
Exemple #4
0
//Get path of program from the main function parameter and Winsock initialization
inline size_t __fastcall FileInit(const PWSTR wPath)
{
/* Get path of program from server information.
//Prepare
	SC_HANDLE SCM = nullptr, Service = nullptr;
	DWORD nResumeHandle = 0;

	if ((SCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS)) == nullptr)
		return EXIT_FAILURE;
 
	Service = OpenService(SCM, LOCAL_SERVICENAME, SERVICE_ALL_ACCESS);
	if (Service == nullptr)
		return EXIT_FAILURE;

	LPQUERY_SERVICE_CONFIG ServicesInfo = (LPQUERY_SERVICE_CONFIG)LocalAlloc(LPTR, QUERY_SERVICE_CONFIG_BUFFER_MAXSIZE);
	if (ServicesInfo == nullptr)
		return EXIT_FAILURE;

	if (QueryServiceConfig(Service, ServicesInfo, QUERY_SERVICE_CONFIG_BUFFER_MAXSIZE, &nResumeHandle) == FALSE)
	{
		LocalFree(ServicesInfo);
		return EXIT_FAILURE;
	}
	Path = ServicesInfo->lpBinaryPathName;
	LocalFree(ServicesInfo);
*/
//Path process.
	Path = wPath;
	Path.erase(Path.rfind(L"\\") + 1U);

	for (size_t Index = 0;Index < Path.length();Index++)
	{
		if (Path[Index] == L'\\')
		{
			Path.insert(Index, L"\\");
			Index++;
		}
	}

//Get path of error log file and delete the old one.
	ErrorLogPath = Path;
	ErrorLogPath.append(L"Error.log");
	DeleteFileW(ErrorLogPath.c_str());
	Parameter.PrintError = true;

//Winsock initialization
	WSADATA WSAInitialization = {0};
	if (WSAStartup(MAKEWORD(2, 2), &WSAInitialization) != 0 || LOBYTE(WSAInitialization.wVersion) != 2 || HIBYTE(WSAInitialization.wVersion) != 2)
	{
		PrintError(WINSOCK_ERROR, L"Winsock initialization error", WSAGetLastError(), nullptr, NULL);

		WSACleanup();
		return EXIT_FAILURE;
	}

	return EXIT_SUCCESS;
}
Exemple #5
0
/*
** Escapes reserved PCRE regex metacharacters.
*/
void EscapeRegExp(std::wstring& str)
{
	size_t start = 0;
	while ((start = str.find_first_of(L"\\^$|()[{.+*?", start)) != std::wstring::npos)
	{
		str.insert(start, L"\\");
		start += 2;
	}
}
Exemple #6
0
bool CWIN32Util::AddExtraLongPathPrefix(std::wstring& path)
{
  const wchar_t* const str = path.c_str();
  if (path.length() < 4 || str[0] != L'\\' || str[1] != L'\\' || str[3] != L'\\' || str[2] != L'?')
  {
    path.insert(0, L"\\\\?\\");
    return true;
  }
  return false;
}
Exemple #7
0
void text::replace(std::wstring &str, const std::wstring &find, const std::wstring &replace)
{
    std::wstring::size_type pos=0;
    while((pos=str.find(find, pos))!=std::wstring::npos)
    {
        str.erase(pos, find.length());
        str.insert(pos, replace);
        pos+=replace.length();
    }
}
Exemple #8
0
size_t Launch(std::wstring FullPathToExe, std::wstring Parameters, size_t SecondsToWait) {
  size_t iMyCounter = 0, iReturnVal = 0, iPos = 0;
  DWORD dwExitCode = 0;
  std::wstring sTempStr = L"";

  /* Add a space to the beginning of the Parameters */
  if (Parameters.size() != 0) {
    if (Parameters[0] != L' ') {
      Parameters.insert(0,L" ");
    }
  }

  /* The first parameter needs to be the exe itself */
  sTempStr = FullPathToExe;
  iPos = sTempStr.find_last_of(L"\\");
  sTempStr.erase(0, iPos +1);
  Parameters = sTempStr.append(Parameters);

   /* CreateProcessW can modify Parameters thus we allocate needed memory */
  wchar_t * pwszParam = new wchar_t[Parameters.size() + 1];
  if (pwszParam == 0)
    return 1;

  const wchar_t* pchrTemp = Parameters.c_str();
  wcscpy_s(pwszParam, Parameters.size() + 1, pchrTemp);

  /* CreateProcess API initialization */
  STARTUPINFOW siStartupInfo;
  PROCESS_INFORMATION piProcessInfo;
  memset(&siStartupInfo, 0, sizeof(siStartupInfo));
  memset(&piProcessInfo, 0, sizeof(piProcessInfo));
  siStartupInfo.cb = sizeof(siStartupInfo);

  if (CreateProcessW(const_cast<LPCWSTR>(FullPathToExe.c_str()),
                    pwszParam, 0, 0, false,
                    CREATE_NO_WINDOW, 0, 0,
                    &siStartupInfo, &piProcessInfo) != false)
     /* Watch the process. */
    dwExitCode = WaitForSingleObject(piProcessInfo.hProcess, (SecondsToWait * 1000));
  else
    /* CreateProcess failed */
    iReturnVal = GetLastError();

  /* Free memory */
  delete[]pwszParam;
  pwszParam = 0;

  /* Release handles */
  CloseHandle(piProcessInfo.hProcess);
  CloseHandle(piProcessInfo.hThread);

  return iReturnVal;
}
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
//
//
// Add the specified char to the left of a string until
//  its length reaches the desidered value
//
//
///////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////
std::wstring dataHandlerDateTimeBase::padLeft(std::wstring source, std::wstring fillChar, size_t length)
{
	PUNTOEXE_FUNCTION_START(L"dataHandlerDateTimeBase::padLeft");

	while(source.size() < length)
	{
		source.insert(0, fillChar);
	}
	return source;

	PUNTOEXE_FUNCTION_END();
}
Exemple #10
0
/*
** Escapes reserved URL characters.
*/
void EncodeUrl(std::wstring& str)
{
	size_t pos = 0;
	while ((pos = str.find_first_of(L" !*'();:@&=+$,/?#[]", pos)) != std::wstring::npos)
	{
		WCHAR buffer[3];
		_snwprintf_s(buffer, _countof(buffer), L"%.2X", str[pos]);
		str[pos] = L'%';
		str.insert(pos + 1, buffer);
		pos += 3;
	}
}
void RecipientsHandler::ReplaceRecipientInString(	const std::wstring& recipient, 
													const int recipientNumber, 
													const RecipientMatch& recipientMatch, 
													std::wstring& recipients)
{
	int currentRecipientNumber = 1; // exclude the first recipient - it should start searching from zero
	std::string::size_type startOfSearchIndex = 0;
	while(recipientNumber > currentRecipientNumber)
	{
		startOfSearchIndex = recipients.find_first_of(L",;", startOfSearchIndex);
		currentRecipientNumber++;
	}

	std::string::size_type startReplaceIndex = recipients.find(recipient, startOfSearchIndex);
	if(std::string::npos == startReplaceIndex)
		return;

	std::string::size_type endReplaceIndex = recipients.find_first_of(L",;", startReplaceIndex);
	if(std::string::npos == endReplaceIndex)
		endReplaceIndex = recipients.size();

	recipients = recipients.erase(startReplaceIndex, endReplaceIndex - startReplaceIndex);

	std::wstring emailAddress;
	if (recipientMatch.GetMailSystem() == AbstractRecipient::NOTES_MAILSYSTEM &&
		!recipientMatch.GetFullName().empty())
	{
		emailAddress = recipientMatch.GetFullName();
	}
	else if(!recipientMatch.GetInternetAddress().empty())
	{
		emailAddress = recipientMatch.GetInternetAddress();
	}
	else if(!recipientMatch.GetMailAddress().empty())
	{
		emailAddress = recipientMatch.GetMailAddress();
	}
	
	if(!emailAddress.empty())
	{
		std::wostringstream msg;
		msg << "Replacing recipient [" << recipient.c_str() << "] with [" << emailAddress.c_str() << "]." << std::ends;
		LOG_WS_INFO(msg.str().c_str());

		recipients = recipients.insert(startReplaceIndex, emailAddress.c_str());
		return;
	}

	LOG_WS_ERROR(L"Error: Cannot replace recipient with empty value!");
}
extern "C" const WCHAR *EncodeWithNickname(const char *string, const WCHAR *szNick, UINT codePage)
{
    static std::wstring msg;
    wchar_t stringW[256];
    int mark = 0;

    MultiByteToWideChar(codePage, 0, string, -1, stringW, 256);
    stringW[255] = 0;
    msg.assign(stringW);
    if((mark = msg.find(L"%nick%")) != msg.npos) {
        msg.erase(mark, 6);
        msg.insert(mark, szNick, lstrlenW(szNick));
    }
    return msg.c_str();
}
Exemple #13
0
    void insertText(const std::wstring& newText)
    {
        // Stop IME composition.
        composition.clear();

        // Delete (overwrite) previous selection.
        if (caretPos != selectionStart) {
            unsigned min = std::min(caretPos, selectionStart);
            unsigned max = std::max(caretPos, selectionStart);
            text.erase(text.begin() + min, text.begin() + max);
            caretPos = selectionStart = min;
        }
        
        text.insert(text.begin() + caretPos, newText.begin(), newText.end());
        caretPos += newText.size();
        selectionStart = caretPos;
    }
Exemple #14
0
std::wstring getAppInstallPath(std::wstring extra)
{
#ifdef NIX
	#if defined(USE_XDG_DIRS)
		std::string installPath = getenv("XDG_DATA_HOME");
		installPath.append("/desura");
	#elif defined(USE_SINGLE_HOME_DIR)
		std::string installPath = getenv("HOME");
		installPath.append("/.desura/games");
	#elif defined(USE_PORTABLE_DIR)
		std::string installPath = UTIL::STRING::toStr(getCurrentDir(L"games"));
	#endif
	
	if (extra.size() > 0)
		extra.insert(0, DIRS_WSTR);
	
	return UTIL::STRING::toWStr(installPath) + extra;
#else
	#error NOT IMPLEMENTED
#endif
}
Exemple #15
0
std::wstring getCachePath(std::wstring extra)
{
#ifdef NIX
	#if defined(USE_XDG_DIRS)
		std::string cachePath = getenv("XDG_CACHE_HOME");
		cachePath.append("/desura");
	#elif defined(USE_SINGLE_HOME_DIR)
		std::string cachePath = getenv("HOME");
		cachePath.append("/.desura/cache");
	#elif defined(USE_PORTABLE_DIR)
		std::string cachePath = UTIL::STRING::toStr(getCurrentDir(L"cache"));
	#endif
	
	if (extra.size() > 0)
		extra.insert(0, DIRS_WSTR);
	
	return UTIL::STRING::toWStr(cachePath) + extra;
#else
	return L"";
//	#error NOT IMPLEMENTED
#endif
}
Exemple #16
0
// create strings
const wchar_t* CreateHelpString(const char *pszStringID)
{
	static std::wstring wsTmp;
	wsTmp = LoadString(pszStringID);

	uint32 nFirst = wsTmp.find_first_of(L"|");
	while (nFirst != std::wstring::npos)
	{
		uint32 nNext = wsTmp.find_first_of(L"|", nFirst+1);

		if (nNext != std::wstring::npos && nNext)
		{
			uint32 nLen = nNext-nFirst;
			std::wstring wsAction;
			if (nLen >= 2) 
			{
				wsAction = wsTmp.substr(nFirst+1,nLen-1);
			}

			wsTmp.erase(nFirst,nLen+1);

			CUserProfile *pProfile = g_pProfileMgr->GetCurrentProfile();
			int nCommand = GetCommandID( MPW2A(wsAction.c_str()).c_str() );
			wchar_t szTriggerName[32] = L"";
			LTStrCpy(szTriggerName,pProfile->GetTriggerNameFromCommandID(nCommand),LTARRAYSIZE(szTriggerName));
			if (LTStrEmpty(szTriggerName))
			{
				LTStrCpy(szTriggerName,LoadString("Control_Unassigned"),LTARRAYSIZE(szTriggerName));
			}
			wsTmp.insert(nFirst,szTriggerName);

		}

		nFirst = wsTmp.find_first_of(L"|");
	}

	return wsTmp.c_str();
}
Exemple #17
0
// ---------------------------------------------------------------------------
void vspPackageWrapper::outputBuildMessage(std::wstring& messageString, bool outputOnlyToLog, std::wstring filePathAndName, int line)
{
    // Add to log:
    VSCORE(vscPrintDebugMsgToDebugLog)(messageString.c_str());

    if (!outputOnlyToLog)
    {
        IVsOutputWindowPane* spOutputWindowPane = getBuildPane();

        if (spOutputWindowPane != NULL)
        {
            HRESULT rc;

            rc = spOutputWindowPane->Activate();
            VSP_ASSERT(rc == S_OK);

            vspDTEConnector::instance().ShowOutputWindow();
            // Add CodeXL prefix to the message (so that the message is identified in the output pane as CodeXL's message)

            // handle a case where the string begins with \n\n\n\n- we don't want to have many "CodeXL-" with no messege
            std::size_t found1 = messageString.find(VS_STR_NewLine);

            if (found1 == 0)
            {
                for (;;)
                {
                    std::size_t found2 = messageString.find(VS_STR_NewLine, found1 + 2);

                    if ((found2 != std::string::npos) && (found1 + 2) == found2)
                    {
                        found1 = found2;
                        continue;
                    }
                    else
                    {
                        break;
                    }
                }

                messageString.insert(found1 + 1, VS_STR_CodeXLPrefix);
            }
            else
            {
                messageString.insert(0, VS_STR_CodeXLPrefix);
            }

            //  when we have a message that's few lines, align lines with codeXL prefix size
            std::size_t found = messageString.find(VS_STR_NewLine);
            std::size_t lastPos = messageString.length() - 1;

            while (found > 0 && found < lastPos)
            {
                messageString.insert(found + 1, VS_STR_CodeXLPrefixIndentation);
                found = messageString.find(VS_STR_NewLine, found + 1);
                lastPos = messageString.length() - 1;
            }

            // verify message ends with new line
            if (lastPos < messageString.length() && (messageString.compare(lastPos, 1, VS_STR_NewLine) != 0))
            {
                messageString += VS_STR_NewLine;
            }

            // Add the message to the debug pane:
            BSTR oleMessageString = SysAllocString(messageString.c_str());

            if (!filePathAndName.empty())
            {
                // message is of the format PATH_TO_FILE\file.cl, line 123:message and will be connected to the actual file and line number
                // connect message to it's location: file and line
                HRESULT res = spOutputWindowPane->OutputTaskItemString(oleMessageString, TP_NORMAL, CAT_BUILDCOMPILE, L"", BMP_COMPILE, filePathAndName.c_str(), line, L"");
                VSP_ASSERT(res == S_OK);

                res = spOutputWindowPane->FlushToTaskList();
                VSP_ASSERT(res == S_OK);
            }
            else
            {
                spOutputWindowPane->OutputString(oleMessageString);
            }

            SysFreeString(oleMessageString);

            // Reduce the reference count
            spOutputWindowPane->Release();
        }
    }
}
size_t ExecuteProcess(_EXCEPTION_POINTERS *pep,std::wstring FullPathToExe, std::wstring Parameters, size_t SecondsToWait)
{
	size_t iMyCounter = 0, iReturnVal = 0, iPos = 0;
	DWORD dwExitCode = 0;
	std::wstring sTempStr = L"";

	/* - NOTE - You should check here to see if the exe even exists */

	/* Add a space to the beginning of the Parameters */
	if (Parameters.size() != 0)
	{
		if (Parameters[0] != L' ')
		{
			Parameters.insert(0,L" ");
		}
	}

	/* The first parameter needs to be the exe itself */
	sTempStr = FullPathToExe;
	iPos = sTempStr.find_last_of(L"\\");
	sTempStr.erase(0, iPos +1);
	Parameters = sTempStr.append(Parameters);

	/* CreateProcessW can modify Parameters thus we allocate needed memory */
	wchar_t * pwszParam = new wchar_t[Parameters.size() + 1];
	if (pwszParam == 0)
	{
		return 1;
	}
	const wchar_t* pchrTemp = Parameters.c_str();
	wcscpy_s(pwszParam, Parameters.size() + 1, pchrTemp);

	/* CreateProcess API initialization */
	STARTUPINFOW siStartupInfo;
	PROCESS_INFORMATION piProcessInfo;
	memset(&siStartupInfo, 0, sizeof(siStartupInfo));
	memset(&piProcessInfo, 0, sizeof(piProcessInfo));
	siStartupInfo.cb = sizeof(siStartupInfo);


	CreatePipe();
	
	if (CreateProcessW(const_cast<LPCWSTR>(FullPathToExe.c_str()),
		pwszParam, 0, 0, false,
		CREATE_DEFAULT_ERROR_MODE /*| CREATE_NEW_CONSOLE | CREATE_NO_WINDOW*/, 0, 0,
		&siStartupInfo, &piProcessInfo) != false)
	{
		// Wait for the process to end

		//printf("Creating pipe and sending message...\n");
		WriteIntoPipe(pep, GetCurrentThreadId());
		//printf("Done with pipe creation.\n");

		//printf("ExecutionHandler: Waiting for the process to end...\n");
		dwExitCode = WaitForSingleObject(piProcessInfo.hProcess, (SecondsToWait * 1000));
		//printf("ExecutionHandler: Process ended (or timeout met)\n");
	}
	else
	{
		// Create Process failed - oh no...
		// TODO: Create a log file describing this
		iReturnVal = GetLastError();
	}
	
	delete[]pwszParam;
	pwszParam = 0;

	CloseHandle(piProcessInfo.hProcess);
	CloseHandle(piProcessInfo.hThread);

	return iReturnVal;
}