org.eclipse.cdt.debug.edc.windows.agent/src/win_agent/ProcessService.cpp - cdt/org.eclipse.cdt.edc - Git at Google

 /*******************************************************************************
  * Copyright (c) 2010 Nokia and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  * Nokia - Initial API and implementation
  *******************************************************************************/
 #include "ProcessService.h"

 #include <algorithm>
 #include <string>
 #include <set>
 #include <Tlhelp32.h>

 #include "TCFHeaders.h"
 #include "TCFChannel.h"
 #include "WinDebugMonitor.h"
 #include "WinProcess.h"
 #include "AgentUtils.h"
 #include "ContextManager.h"
 #include "EventClientNotifier.h"
 #include "Logger.h"
 #include "DetachProcessAction.h"

 static const char * sServiceName = "Processes";

 static std::string quoteIfNeeded(const char* source);

 ProcessService::ProcessService(Protocol * proto) :
 	TCFService(proto) {
 	AddCommand("getContext", command_get_context);
 	AddCommand("getChildren", command_get_children);
 	AddCommand("attach", command_attach);
 	AddCommand("detach", command_detach);
 	AddCommand("terminate", command_terminate);
 	AddCommand("signal", command_signal);
 	AddCommand("getEnvironment", command_get_environment);
 	AddCommand("start", command_start);
 }

 ProcessService::~ProcessService(void) {
 }

 const char* ProcessService::GetName() {
 	return sServiceName;
 }

 /*
  * This will return a context, running or debugged one.
  */
 void ProcessService::command_get_context(const char * token, Channel * c) {
 	LogTrace("ProcessService::command_get_context", "token: %s", token);
 	TCFChannel channel(c);

 	std::string id = channel.readString();
 	channel.readZero();
 	channel.readComplete();

 	Context* context = ContextManager::findContext(id);
 	if (context == NULL) {
 		// Return an invalid context ID error.
 		channel.writeCompleteReply(token, ERR_INV_CONTEXT, 1);
 		return;
 	}

 	channel.writeReplyHeader(token);
 	channel.writeError(0);
 	EventClientNotifier::WriteContext(*context, channel);
 	channel.writeZero();
 	channel.writeComplete();
 }

 /** Filter to get choose Contexts which are the top-level RunControlContext that were from the
  * previous Processes::getChildren call.  Ignore those that are being debugged. */
 static bool IsNotRunningProcessContext(const ContextID& contextID) {
 	Context* context = ContextManager::findContext(contextID);
 	ProcessContext* rcContext = dynamic_cast<ProcessContext*>(context);
 	trace(LOG_ALWAYS, "Context %s: isRC=%d, isDebugging=%d", contextID.c_str(), rcContext!=0, rcContext && rcContext->IsDebugging());
 	return !rcContext || rcContext->IsDebugging();
 }
 /** Remove and delete a context by value. */
 static void RemoveAndDeleteContext(const ContextID& contextID) {
 	trace(LOG_ALWAYS, "Removing context %s", contextID.c_str());
 	delete ContextManager::removeContext(contextID);
 }

 void ProcessService::command_get_children(const char * token, Channel * c) {
     char id[256];
     int attached_only;

     json_read_string(&c->inp, id, sizeof(id));
     if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
     attached_only = json_read_boolean(&c->inp);
     if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
     if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);

     write_stringz(&c->out, "R");
     write_stringz(&c->out, token);

     if (id[0] != 0) {
         write_errno(&c->out, 0);
         write_stringz(&c->out, "null");
     }
     else {
         DWORD err = 0;
         HANDLE snapshot;
         PROCESSENTRY32 pe32;

         snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
         if (snapshot == INVALID_HANDLE_VALUE) err = set_win32_errno(GetLastError());
         memset(&pe32, 0, sizeof(pe32));
         pe32.dwSize = sizeof(PROCESSENTRY32);
         if (!err && !Process32First(snapshot, &pe32)) {
             err = set_win32_errno(GetLastError());
             CloseHandle(snapshot);
         }
         write_errno(&c->out, err);
         if (err) {
             write_stringz(&c->out, "null");
         }
         else {
         	// Get all the known contexts
         	std::list<ContextID> runContexts = ContextManager::getContexts();

         	// Shuffle to the end the ones we want to remove
         	std::list<ContextID>::iterator removeEnd = std::remove_if(runContexts.begin(), runContexts.end(),
         			IsNotRunningProcessContext);

         	// Remove these entries from the manager
         	std::for_each(runContexts.begin(), removeEnd, RemoveAndDeleteContext);

             int cnt = 0;
             write_stream(&c->out, '[');

             do {
                 if (!attached_only || WinProcess::GetProcessByID(pe32.th32ProcessID) != NULL) {
                     if (cnt > 0) write_stream(&c->out, ',');
                     // We just pass the OS process ID.

                     // If context still exists, it is being debugged, so leave it be.
 					WinProcess* process = dynamic_cast<WinProcess*>(ContextManager::findContext(
 							WinProcess::CreateInternalID(pe32.th32ProcessID)));

 					if (!process) {
 						process = new WinProcess(pe32.th32ProcessID, pe32.szExeFile);
 						ContextManager::addContext(process);
 					}

 					// Tell host the unique internal ID.
 					json_write_string(&c->out, process->GetID().c_str());

                     cnt++;
                 }
             } while (Process32Next(snapshot, &pe32));

             write_stream(&c->out, ']');
             write_stream(&c->out, 0);
         }
         if (snapshot != INVALID_HANDLE_VALUE)
         	CloseHandle(snapshot);
     }

     write_stream(&c->out, MARKER_EOM);
 }

 void ProcessService::command_attach(const char * token, Channel * c) {
 	LogTrace("ProcessService::command_attach", "token: %s", token);
 	TCFChannel channel(c);
 	std::string id = channel.readString();
 	channel.readZero();
 	channel.readComplete();

 	RunControlContext* context = dynamic_cast<RunControlContext*>(ContextManager::findContext(id));

 	// TODO: or not running
 	if (context == NULL) {
 		// Return an invalid context ID error.
 		channel.writeCompleteReply(token, ERR_INV_CONTEXT);
 		return;
 	}

 	// This function will report result to host debugger.

 	AttachToProcessParams params(token, c, context->GetOSID(), true);
 	WinDebugMonitor::AttachToProcess(params);

 }

 void ProcessService::command_detach(const char * token, Channel * c) {
 	LogTrace("ProcessService::command_detach", "token: %s", token);
 	TCFChannel channel(c);
 	std::string id = channel.readString();
 	channel.readZero();
 	channel.readComplete();

 	WinProcess* context = dynamic_cast<WinProcess*>(ContextManager::findContext(id));

 	if (context == NULL || !context->IsDebugging()) {
 		// Return an invalid context ID error.
 		channel.writeCompleteReply(token, ERR_INV_CONTEXT);
 		return;
 	}

 	context->GetMonitor()->PostAction(new DetachProcessAction(
 			AgentActionParams(token, c), context->GetOSID()));
 }

 void ProcessService::command_terminate(const char * token, Channel * c) {
 }

 void ProcessService::command_signal(const char * token, Channel * c) {
 }

 void ProcessService::command_get_environment(const char * token, Channel * c) {
 	char ** p = environ;

 	TCFChannel channel(c);
 	channel.readComplete();

 	channel.writeReplyHeader(token);
 	channel.writeError(0);

 	channel.writeCharacter('[');
 	if (p != NULL) {
 		while (*p != NULL) {
 			if (p != environ)
 				channel.writeCharacter(',');
 			json_write_string(&c->out, *p++);
 		}
 	}
 	channel.writeCharacter(']');
 	channel.writeZero();
 	channel.writeComplete();
 }

 std::wstring json_read_string(Channel * c) {
 	char stringbuffer[4096];
 	json_read_string(&c->inp, stringbuffer, sizeof(stringbuffer));
 	if (c->inp.read(&c->inp) != 0)
 		exception(ERR_JSON_SYNTAX);

 	int wideSize = MultiByteToWideChar(CP_UTF8, 0, stringbuffer, strlen(
 			stringbuffer) + 1, NULL, 0);
 	wchar_t* wideChars = new wchar_t[wideSize];
 	MultiByteToWideChar(CP_UTF8, 0, stringbuffer, strlen(stringbuffer) + 1,
 			wideChars, wideSize);
 	std::wstring result = wideChars;
 	delete[] wideChars;
 	return result;
 }

 void ProcessService::command_start(const char * token, Channel * c) {
 	TCFChannel channel(c);
 	std::string directory = channel.readString();
 	channel.readZero();
 	std::string executable = channel.readString();
 	channel.readZero();

 	char ** args = NULL;
 	char ** envp = NULL;
 	int args_len = 0;
 	int envp_len = 0;

 	args = json_read_alloc_string_array(&c->inp, &args_len);
 	if (c->inp.read(&c->inp) != 0)
 		exception(ERR_JSON_SYNTAX);
 	envp = json_read_alloc_string_array(&c->inp, &envp_len);
 	if (c->inp.read(&c->inp) != 0)
 		exception(ERR_JSON_SYNTAX);

 	std::vector<std::string> environment;
 	for (int i = 0; i < envp_len; i++)
 	{
 		environment.push_back(envp[i]);
 	}

 	// this is the "attach" parameter, but note that in this case
 	// it's really if you want to stay attached to the process we're
 	// launching in order to debug it, vs. just launching it in order
 	// to run it (without debugging).  for attaching to an existing
 	// process, command_attach will be called.
 // TODO currently ignored, but we need to honor it if/when we add
 // support for running vs. debugging.
 /*	bool debug = */ json_read_boolean(&c->inp); // attach

 	if (read_stream(&c->inp) != 0)
 		exception(ERR_JSON_SYNTAX);
 	channel.readComplete();

 	std::string wargs;

 	wargs += quoteIfNeeded(executable.c_str());
 	for (int i = 0; i < args_len; i++) {
 		wargs += ' ';
 		wargs += quoteIfNeeded(args[i]);
 	}

 	loc_free(args);
 	loc_free(envp);

 	LaunchProcessParams params(token, c, executable, directory, wargs, environment, true);
 	WinDebugMonitor::LaunchProcess(params);

 }


 /**
  * Escape a string for the Win32 command line.
  *
  * Adapted from Win32ProcessEx.c in spawner:
  *
  * Copyright (c) 2002, 2010 QNX Software Systems and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     QNX Software Systems - initial API and implementation
  *     Wind River Systems, Inc.
  *******************************************************************************/

 static std::string quoteIfNeeded(const char* source) {
 	std::string target;
 	int cpyLength = strlen(source);

 	BOOL bSlash = FALSE;
 	int i = 0;

 #define QUOTATION_DO   0
 #define QUOTATION_DONE 1
 #define QUOTATION_NONE 2
 #undef _T
 #define _T(x) x

 	int nQuotationMode = 0;

 	if((_T('\"') == *source) && (_T('\"') == *(source + cpyLength - 1)))
 		{
 		nQuotationMode = QUOTATION_DONE;
 		}
 	else
 	if(strchr(source, _T(' ')) == NULL)
 		{
 		// No reason to quotate term becase it doesn't have embedded spaces
 		nQuotationMode = QUOTATION_NONE;
 		}
 	else
 		{
 		// Needs to be quotated
 		nQuotationMode = QUOTATION_DO;
 		target += _T('\"');
 		}


 	for(; i < cpyLength; ++i)
 		{
 		if(source[i] == _T('\\'))
 			bSlash = TRUE;
 		else
 			{
 			// Don't quote embracing quotation marks
 			if((source[i] == _T('\"')) && !((nQuotationMode == QUOTATION_DONE) && ((i == 0) || (i == (cpyLength - 1))) ) )
 				{
 				if(!bSlash) // If still not escaped
 					{
 					target += _T('\\');
 					}
 				}
 			bSlash = FALSE;
 			}

 		target += source[i];
 		}

 	if(nQuotationMode == QUOTATION_DO)
 		{
 		target += _T('\"');
 		}

 	return target;
 }
	/*******************************************************************************
	* Copyright (c) 2010 Nokia and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Nokia - Initial API and implementation
	*******************************************************************************/
	#include "ProcessService.h"

	#include <algorithm>
	#include <string>
	#include <set>
	#include <Tlhelp32.h>

	#include "TCFHeaders.h"
	#include "TCFChannel.h"
	#include "WinDebugMonitor.h"
	#include "WinProcess.h"
	#include "AgentUtils.h"
	#include "ContextManager.h"
	#include "EventClientNotifier.h"
	#include "Logger.h"
	#include "DetachProcessAction.h"

	static const char * sServiceName = "Processes";

	static std::string quoteIfNeeded(const char* source);

	ProcessService::ProcessService(Protocol * proto) :
	TCFService(proto) {
	AddCommand("getContext", command_get_context);
	AddCommand("getChildren", command_get_children);
	AddCommand("attach", command_attach);
	AddCommand("detach", command_detach);
	AddCommand("terminate", command_terminate);
	AddCommand("signal", command_signal);
	AddCommand("getEnvironment", command_get_environment);
	AddCommand("start", command_start);
	}

	ProcessService::~ProcessService(void) {
	}

	const char* ProcessService::GetName() {
	return sServiceName;
	}

	/*
	* This will return a context, running or debugged one.
	*/
	void ProcessService::command_get_context(const char * token, Channel * c) {
	LogTrace("ProcessService::command_get_context", "token: %s", token);
	TCFChannel channel(c);

	std::string id = channel.readString();
	channel.readZero();
	channel.readComplete();

	Context* context = ContextManager::findContext(id);
	if (context == NULL) {
	// Return an invalid context ID error.
	channel.writeCompleteReply(token, ERR_INV_CONTEXT, 1);
	return;
	}

	channel.writeReplyHeader(token);
	channel.writeError(0);
	EventClientNotifier::WriteContext(*context, channel);
	channel.writeZero();
	channel.writeComplete();
	}

	/** Filter to get choose Contexts which are the top-level RunControlContext that were from the
	* previous Processes::getChildren call. Ignore those that are being debugged. */
	static bool IsNotRunningProcessContext(const ContextID& contextID) {
	Context* context = ContextManager::findContext(contextID);
	ProcessContext* rcContext = dynamic_cast<ProcessContext*>(context);
	trace(LOG_ALWAYS, "Context %s: isRC=%d, isDebugging=%d", contextID.c_str(), rcContext!=0, rcContext && rcContext->IsDebugging());
	return !rcContext \|\| rcContext->IsDebugging();
	}
	/** Remove and delete a context by value. */
	static void RemoveAndDeleteContext(const ContextID& contextID) {
	trace(LOG_ALWAYS, "Removing context %s", contextID.c_str());
	delete ContextManager::removeContext(contextID);
	}

	void ProcessService::command_get_children(const char * token, Channel * c) {
	char id[256];
	int attached_only;

	json_read_string(&c->inp, id, sizeof(id));
	if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
	attached_only = json_read_boolean(&c->inp);
	if (read_stream(&c->inp) != 0) exception(ERR_JSON_SYNTAX);
	if (read_stream(&c->inp) != MARKER_EOM) exception(ERR_JSON_SYNTAX);

	write_stringz(&c->out, "R");
	write_stringz(&c->out, token);

	if (id[0] != 0) {
	write_errno(&c->out, 0);
	write_stringz(&c->out, "null");
	}
	else {
	DWORD err = 0;
	HANDLE snapshot;
	PROCESSENTRY32 pe32;

	snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if (snapshot == INVALID_HANDLE_VALUE) err = set_win32_errno(GetLastError());
	memset(&pe32, 0, sizeof(pe32));
	pe32.dwSize = sizeof(PROCESSENTRY32);
	if (!err && !Process32First(snapshot, &pe32)) {
	err = set_win32_errno(GetLastError());
	CloseHandle(snapshot);
	}
	write_errno(&c->out, err);
	if (err) {
	write_stringz(&c->out, "null");
	}
	else {
	// Get all the known contexts
	std::list<ContextID> runContexts = ContextManager::getContexts();

	// Shuffle to the end the ones we want to remove
	std::list<ContextID>::iterator removeEnd = std::remove_if(runContexts.begin(), runContexts.end(),
	IsNotRunningProcessContext);

	// Remove these entries from the manager
	std::for_each(runContexts.begin(), removeEnd, RemoveAndDeleteContext);

	int cnt = 0;
	write_stream(&c->out, '[');

	do {
	if (!attached_only \|\| WinProcess::GetProcessByID(pe32.th32ProcessID) != NULL) {
	if (cnt > 0) write_stream(&c->out, ',');
	// We just pass the OS process ID.

	// If context still exists, it is being debugged, so leave it be.
	WinProcess* process = dynamic_cast<WinProcess*>(ContextManager::findContext(
	WinProcess::CreateInternalID(pe32.th32ProcessID)));

	if (!process) {
	process = new WinProcess(pe32.th32ProcessID, pe32.szExeFile);
	ContextManager::addContext(process);
	}

	// Tell host the unique internal ID.
	json_write_string(&c->out, process->GetID().c_str());

	cnt++;
	}
	} while (Process32Next(snapshot, &pe32));

	write_stream(&c->out, ']');
	write_stream(&c->out, 0);
	}
	if (snapshot != INVALID_HANDLE_VALUE)
	CloseHandle(snapshot);
	}

	write_stream(&c->out, MARKER_EOM);
	}

	void ProcessService::command_attach(const char * token, Channel * c) {
	LogTrace("ProcessService::command_attach", "token: %s", token);
	TCFChannel channel(c);
	std::string id = channel.readString();
	channel.readZero();
	channel.readComplete();

	RunControlContext* context = dynamic_cast<RunControlContext*>(ContextManager::findContext(id));

	// TODO: or not running
	if (context == NULL) {
	// Return an invalid context ID error.
	channel.writeCompleteReply(token, ERR_INV_CONTEXT);
	return;
	}

	// This function will report result to host debugger.

	AttachToProcessParams params(token, c, context->GetOSID(), true);
	WinDebugMonitor::AttachToProcess(params);

	}

	void ProcessService::command_detach(const char * token, Channel * c) {
	LogTrace("ProcessService::command_detach", "token: %s", token);
	TCFChannel channel(c);
	std::string id = channel.readString();
	channel.readZero();
	channel.readComplete();

	WinProcess* context = dynamic_cast<WinProcess*>(ContextManager::findContext(id));

	if (context == NULL \|\| !context->IsDebugging()) {
	// Return an invalid context ID error.
	channel.writeCompleteReply(token, ERR_INV_CONTEXT);
	return;
	}

	context->GetMonitor()->PostAction(new DetachProcessAction(
	AgentActionParams(token, c), context->GetOSID()));
	}

	void ProcessService::command_terminate(const char * token, Channel * c) {
	}

	void ProcessService::command_signal(const char * token, Channel * c) {
	}

	void ProcessService::command_get_environment(const char * token, Channel * c) {
	char ** p = environ;

	TCFChannel channel(c);
	channel.readComplete();

	channel.writeReplyHeader(token);
	channel.writeError(0);

	channel.writeCharacter('[');
	if (p != NULL) {
	while (*p != NULL) {
	if (p != environ)
	channel.writeCharacter(',');
	json_write_string(&c->out, *p++);
	}
	}
	channel.writeCharacter(']');
	channel.writeZero();
	channel.writeComplete();
	}

	std::wstring json_read_string(Channel * c) {
	char stringbuffer[4096];
	json_read_string(&c->inp, stringbuffer, sizeof(stringbuffer));
	if (c->inp.read(&c->inp) != 0)
	exception(ERR_JSON_SYNTAX);

	int wideSize = MultiByteToWideChar(CP_UTF8, 0, stringbuffer, strlen(
	stringbuffer) + 1, NULL, 0);
	wchar_t* wideChars = new wchar_t[wideSize];
	MultiByteToWideChar(CP_UTF8, 0, stringbuffer, strlen(stringbuffer) + 1,
	wideChars, wideSize);
	std::wstring result = wideChars;
	delete[] wideChars;
	return result;
	}

	void ProcessService::command_start(const char * token, Channel * c) {
	TCFChannel channel(c);
	std::string directory = channel.readString();
	channel.readZero();
	std::string executable = channel.readString();
	channel.readZero();

	char ** args = NULL;
	char ** envp = NULL;
	int args_len = 0;
	int envp_len = 0;

	args = json_read_alloc_string_array(&c->inp, &args_len);
	if (c->inp.read(&c->inp) != 0)
	exception(ERR_JSON_SYNTAX);
	envp = json_read_alloc_string_array(&c->inp, &envp_len);
	if (c->inp.read(&c->inp) != 0)
	exception(ERR_JSON_SYNTAX);

	std::vector<std::string> environment;
	for (int i = 0; i < envp_len; i++)
	{
	environment.push_back(envp[i]);
	}

	// this is the "attach" parameter, but note that in this case
	// it's really if you want to stay attached to the process we're
	// launching in order to debug it, vs. just launching it in order
	// to run it (without debugging). for attaching to an existing
	// process, command_attach will be called.
	// TODO currently ignored, but we need to honor it if/when we add
	// support for running vs. debugging.
	/* bool debug = */ json_read_boolean(&c->inp); // attach

	if (read_stream(&c->inp) != 0)
	exception(ERR_JSON_SYNTAX);
	channel.readComplete();

	std::string wargs;

	wargs += quoteIfNeeded(executable.c_str());
	for (int i = 0; i < args_len; i++) {
	wargs += ' ';
	wargs += quoteIfNeeded(args[i]);
	}

	loc_free(args);
	loc_free(envp);

	LaunchProcessParams params(token, c, executable, directory, wargs, environment, true);
	WinDebugMonitor::LaunchProcess(params);

	}


	/**
	* Escape a string for the Win32 command line.
	*
	* Adapted from Win32ProcessEx.c in spawner:
	*
	* Copyright (c) 2002, 2010 QNX Software Systems and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* QNX Software Systems - initial API and implementation
	* Wind River Systems, Inc.
	*******************************************************************************/

	static std::string quoteIfNeeded(const char* source) {
	std::string target;
	int cpyLength = strlen(source);

	BOOL bSlash = FALSE;
	int i = 0;

	#define QUOTATION_DO 0
	#define QUOTATION_DONE 1
	#define QUOTATION_NONE 2
	#undef _T
	#define _T(x) x

	int nQuotationMode = 0;

	if((_T('\"') == source) && (_T('\"') == (source + cpyLength - 1)))
	{
	nQuotationMode = QUOTATION_DONE;
	}
	else
	if(strchr(source, _T(' ')) == NULL)
	{
	// No reason to quotate term becase it doesn't have embedded spaces
	nQuotationMode = QUOTATION_NONE;
	}
	else
	{
	// Needs to be quotated
	nQuotationMode = QUOTATION_DO;
	target += _T('\"');
	}


	for(; i < cpyLength; ++i)
	{
	if(source[i] == _T('\\'))
	bSlash = TRUE;
	else
	{
	// Don't quote embracing quotation marks
	if((source[i] == _T('\"')) && !((nQuotationMode == QUOTATION_DONE) && ((i == 0) \|\| (i == (cpyLength - 1))) ) )
	{
	if(!bSlash) // If still not escaped
	{
	target += _T('\\');
	}
	}
	bSlash = FALSE;
	}

	target += source[i];
	}

	if(nQuotationMode == QUOTATION_DO)
	{
	target += _T('\"');
	}

	return target;
	}