development/org.eclipse.wst.jsdt.debug.ie/IECrossfireServer/CrossfireServer.cpp - jsdt/webtools.jsdt.debug - Git at Google

 /*******************************************************************************
  * Copyright (c) 2011 IBM Corporation 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:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/


 #include "stdafx.h"
 #include "CrossfireServer.h"

 /* initialize statics */
 const wchar_t* CrossfireServer::CONTEXTID_PREAMBLE = L"xfIE::";
 const wchar_t* CrossfireServer::HANDSHAKE = L"CrossfireHandshake\r\n";
 const wchar_t* CrossfireServer::HEADER_CONTENTLENGTH = L"Content-Length:";
 const wchar_t* CrossfireServer::LINEBREAK = L"\r\n";
 const size_t CrossfireServer::LINEBREAK_LENGTH = 2;

 const wchar_t* CrossfireServer::COMMAND_CHANGEBREAKPOINT = L"changebreakpoint";
 const wchar_t* CrossfireServer::COMMAND_CLEARBREAKPOINT = L"clearbreakpoint";
 const wchar_t* CrossfireServer::COMMAND_GETBREAKPOINT = L"getbreakpoint";
 const wchar_t* CrossfireServer::COMMAND_GETBREAKPOINTS = L"getbreakpoints";
 const wchar_t* CrossfireServer::COMMAND_SETBREAKPOINT = L"setbreakpoint";

 /* command: listContexts */
 const wchar_t* CrossfireServer::COMMAND_LISTCONTEXTS = L"listcontexts";
 const wchar_t* CrossfireServer::KEY_CONTEXTS = L"contexts";
 const wchar_t* CrossfireServer::KEY_CURRENT = L"current";

 /* command: version */
 const wchar_t* CrossfireServer::COMMAND_VERSION = L"version";
 const wchar_t* CrossfireServer::KEY_VERSION = L"version";
 const wchar_t* CrossfireServer::VERSION_STRING = L"0.3";

 /* event: closed */
 const wchar_t* CrossfireServer::EVENT_CLOSED = L"closed";

 /* event: onContextChanged */
 const wchar_t* CrossfireServer::EVENT_CONTEXTCHANGED = L"onContextChanged";
 const wchar_t* CrossfireServer::KEY_NEWHREF = L"new-href";

 /* event: onContextCreated */
 const wchar_t* CrossfireServer::EVENT_CONTEXTCREATED = L"onContextCreated";

 /* event: onContextDestroyed */
 const wchar_t* CrossfireServer::EVENT_CONTEXTDESTROYED = L"onContextDestroyed";

 /* event: onContextLoaded */
 const wchar_t* CrossfireServer::EVENT_CONTEXTLOADED = L"onContextLoaded";

 /* shared */
 const wchar_t* CrossfireServer::KEY_HREF = L"href";


 CrossfireServer::CrossfireServer() {
 	m_bpManager = new CrossfireBPManager();
 	m_connection = NULL;
 	m_contexts = new std::map<DWORD, CrossfireContext*>;
 	m_currentContext = NULL;
 	m_handshakeReceived = false;
 	m_inProgressPacket = new std::wstring;
 	m_lastRequestSeq = -1;
 	m_pendingEvents = new std::vector<CrossfireEvent*>;
 	m_port = -1;
 	m_processingRequest = false;
 	m_processor = new CrossfireProcessor();
 	m_windowHandle = 0;
 }

 CrossfireServer::~CrossfireServer() {
 	delete m_bpManager;

 	std::map<DWORD,CrossfireContext*>::iterator iterator = m_contexts->begin();
 	while (iterator != m_contexts->end()) {
 		delete iterator->second;
 		iterator++;
 	}
 	delete m_contexts;

 	std::vector<CrossfireEvent*>::iterator iterator2 = m_pendingEvents->begin();
 	while (iterator2 != m_pendingEvents->end()) {
 		if (m_connection) {
 			sendEvent(*iterator2);
 		}
 		delete *iterator2;
 		iterator2++;
 	}
 	delete m_pendingEvents;

 	delete m_inProgressPacket;
 	delete m_processor;
 	if (m_connection) {
 		delete m_connection;
 	}

 	if (m_windowHandle) {
 		CComPtr<ICrossfireServerClass> serverClass = NULL;
 		HRESULT hr = CoGetClassObject(CLSID_CrossfireServer, CLSCTX_ALL, 0, IID_ICrossfireServerClass, (LPVOID*)&serverClass);
 		if (FAILED(hr)) {
 			Logger::error("~CrossfireServer: CoGetClassObject() failed", hr);
 			return;
 		}
 		hr = serverClass->RemoveServer(m_windowHandle);
 		if (FAILED(hr)) {
 			Logger::error("~CrossfireServer: RemoveServer() failed", hr);
 			return;
 		}
 	}
 }

 HRESULT STDMETHODCALLTYPE CrossfireServer::contextCreated(DWORD threadId, OLECHAR* href) {
 	if (m_port == -1) {
 		return S_FALSE;
 	}

 	HRESULT hr = registerContext(threadId, href);
 	if (SUCCEEDED(hr)) {
 		std::map<DWORD, CrossfireContext*>::iterator iterator = m_contexts->find(threadId);
 		CrossfireContext* context = iterator->second;
 		eventContextCreated(context);
 	}
 	return hr;
 }

 HRESULT STDMETHODCALLTYPE CrossfireServer::contextDestroyed(DWORD threadId) {
 	if (m_port == -1) {
 		return S_FALSE;
 	}

 	std::map<DWORD, CrossfireContext*>::iterator iterator = m_contexts->find(threadId);
 	if (iterator == m_contexts->end()) {
 		Logger::error("CrossfireServer.contextDestroyed(): unknown context", threadId);
 		return S_FALSE;
 	}
 	CrossfireContext* context = iterator->second;
 	eventContextDestroyed(context);
 	m_contexts->erase(iterator);
 	delete context;
 	return S_OK;
 }

 HRESULT STDMETHODCALLTYPE CrossfireServer::contextLoaded(DWORD threadId) {
 	if (m_port == -1) {
 		return S_FALSE;
 	}

 	std::map<DWORD, CrossfireContext*>::iterator iterator = m_contexts->find(threadId);
 	if (iterator == m_contexts->end()) {
 		Logger::error("CrossfireServer.contextLoaded(): unknown context", threadId);
 		return S_FALSE;
 	}
 	CrossfireContext* context = iterator->second;
 	eventContextLoaded(context);
 	return S_OK;
 }

 void CrossfireServer::disconnected() {
 	reset();
 }

 CrossfireBPManager* CrossfireServer::getBreakpointManager() {
 	return m_bpManager;
 }

 CrossfireContext* CrossfireServer::getRequestContext(CrossfireRequest* request) {
 	std::wstring* contextId = request->getContextId();
 	if (!contextId) {
 		return NULL;
 	}

 	wchar_t* searchString = (wchar_t*)contextId->c_str();
 	std::map<DWORD,CrossfireContext*>::iterator iterator = m_contexts->begin();
 	while (iterator != m_contexts->end()) {
 		if (wcscmp(iterator->second->getName(), searchString) == 0) {
 			return iterator->second;
 		}
 		iterator++;
 	}
 	return NULL;
 }

 HRESULT STDMETHODCALLTYPE CrossfireServer::isActive(boolean* value) {
 	*value = m_port != -1;
 	return S_OK;
 }

 bool CrossfireServer::performRequest(CrossfireRequest* request) {
 	wchar_t* command = request->getName();
 	Value* arguments = request->getArguments();
 	Value* responseBody = NULL;
 	bool success = false;
 	if (wcscmp(command, COMMAND_VERSION) == 0) {
 		success = commandVersion(arguments, &responseBody);
 	} else if (wcscmp(command, COMMAND_CHANGEBREAKPOINT) == 0) {
 		CrossfireContext* context = getRequestContext(request);
 		IBreakpointTarget* target = context ? (IBreakpointTarget*)context : (IBreakpointTarget*)m_bpManager;
 		success = m_bpManager->commandChangeBreakpoint(arguments, target, &responseBody);
 	} else if (wcscmp(command, COMMAND_CLEARBREAKPOINT) == 0) {
 		CrossfireContext* context = getRequestContext(request);
 		IBreakpointTarget* target = context ? (IBreakpointTarget*)context : (IBreakpointTarget*)m_bpManager;
 		success = m_bpManager->commandClearBreakpoint(arguments, target, &responseBody);
 	} else if (wcscmp(command, COMMAND_LISTCONTEXTS) == 0) {
 		success = commandListContexts(arguments, &responseBody);
 	} else if (wcscmp(command, COMMAND_GETBREAKPOINT) == 0) {
 		CrossfireContext* context = getRequestContext(request);
 		IBreakpointTarget* target = context ? (IBreakpointTarget*)context : (IBreakpointTarget*)m_bpManager;
 		success = m_bpManager->commandGetBreakpoint(arguments, target, &responseBody);
 	} else if (wcscmp(command, COMMAND_GETBREAKPOINTS) == 0) {
 		CrossfireContext* context = getRequestContext(request);
 		IBreakpointTarget* target = context ? (IBreakpointTarget*)context : (IBreakpointTarget*)m_bpManager;
 		success = m_bpManager->commandGetBreakpoints(arguments, target, &responseBody);
 	} else if (wcscmp(command, COMMAND_SETBREAKPOINT) == 0) {
 		CrossfireContext* context = getRequestContext(request);
 		IBreakpointTarget* target = context ? (IBreakpointTarget*)context : (IBreakpointTarget*)m_bpManager;
 		success = m_bpManager->commandSetBreakpoint(arguments, target, &responseBody);
 	} else {
 		return false;	/* command not handled */
 	}

 	CrossfireResponse response;
 	response.setName(command);
 	response.setRequestSeq(request->getSeq());
 	response.setRunning(true);
 	response.setSuccess(success);
 	if (success) {
 		response.setBody(responseBody);
 	} else {
 		Value emptyBody;
 		emptyBody.setType(TYPE_OBJECT);
 		response.setBody(&emptyBody);
 	}
 	if (responseBody) {
 		delete responseBody;
 	}
 	sendResponse(&response);
 	return true;
 }

 void CrossfireServer::received(wchar_t* msg) {
 	if (!m_handshakeReceived) {
 		if (wcscmp(msg, HANDSHAKE) == 0) {
 			m_handshakeReceived = true;
 			m_connection->send(HANDSHAKE);
 		} else {
 			Logger::error("Crossfire content received before handshake, not processing it");
 		}
 		return;
 	}

 	m_inProgressPacket->append(std::wstring(msg));
 	std::wstring packet;
 	do {
 		packet.clear();
 		if (m_inProgressPacket->find(HEADER_CONTENTLENGTH) != 0) {
 			Logger::error("request packet does not start with 'Content-Length:', not processing it");
 			Logger::log(m_inProgressPacket);
 			m_inProgressPacket->clear();
 			break;
 		}

 		size_t endIndex = m_inProgressPacket->find(wchar_t('\r'));
 		if (endIndex == std::wstring::npos) {
 			Logger::error("request packet does not contain '\r', not processing it");
 			Logger::log(m_inProgressPacket);
 			m_inProgressPacket->clear();
 			break;
 		}

 		size_t headerLength = wcslen(HEADER_CONTENTLENGTH);
 		std::wstring lengthString = m_inProgressPacket->substr(headerLength, endIndex - headerLength);
 		int lengthValue = _wtoi(lengthString.c_str());
 		if (!lengthValue) {
 			Logger::error("request packet does not have a valid 'Content-Length' value, not processing it");
 			Logger::log(m_inProgressPacket);
 			m_inProgressPacket->clear();
 			break;
 		}

 		if (m_inProgressPacket->find(L"\r\n", endIndex) != endIndex) {
 			Logger::error("request packet does not follow initial '\\r' with '\\n', not processing it");
 			Logger::log(m_inProgressPacket);
 			m_inProgressPacket->clear();
 			break;
 		}

 		// TODO for now just skip over "tool:" lines, though these should really be validated

 		size_t toolEnd = m_inProgressPacket->find(L"\r\n\r\n", endIndex);
 		if (toolEnd == std::wstring::npos) {
 			Logger::error("request packet does not contain '\\r\\n\\r\\n' to delimit its header, not processing it");
 			Logger::log(m_inProgressPacket);
 			m_inProgressPacket->clear();
 			break;
 		}
 		size_t toolsLength = toolEnd - endIndex;
 		size_t targetLength = wcslen(HEADER_CONTENTLENGTH) + lengthString.length() + 3 * LINEBREAK_LENGTH + toolsLength + lengthValue;

 		if (targetLength <= m_inProgressPacket->length()) {
 			packet.assign(m_inProgressPacket->substr(0, targetLength));
 			m_inProgressPacket->erase(0, targetLength);
 		}

 		if (packet.length()) {
 			CrossfireRequest* request = NULL;
 			if (!m_processor->parseRequestPacket(&packet, &request)) {
 				Logger::error("invalid request packet received, not processing it");
 				Logger::log(&packet);
 			} else {
 				unsigned int seq = request->getSeq();
 				if (seq <= m_lastRequestSeq) {
 					// TODO handle out-of-order packets
 					Logger::log("packet received out of sequence, still processing it");
 				}
 				m_lastRequestSeq = seq;
 				m_processingRequest = true;
 				if (!performRequest(request)) {
 					/*
 					 * the request's command was not handled by the server,
 					 * so try to delegate to the specified context, if any
 					 */
 					CrossfireContext* context = getRequestContext(request);
 					if (!context) {
 						Logger::error("request command was unknown to the server and a valid context id was not provided, not processing it");
 						Logger::log(&packet);
 					} else {
 						if (!context->performRequest(request)) {
 							Logger::error("request command was unknown to the server and to the specified context, not processing it");
 							Logger::log(&packet);
 						}
 					}
 				}
 				m_processingRequest = false;
 				delete request;

 				/*
 				 * Debugger events may have been received in response to the request that was
 				 * just processed.  These events can be sent now that processing of the request
 				 * is complete.
 				 */
 				if (m_pendingEvents->size() > 0) {
 // GWG HACK! helps JSDT with stepping
 Logger::error("start sleep");
 Sleep(500);
 Logger::error("end sleep");

 					std::vector<CrossfireEvent*>::iterator iterator = m_pendingEvents->begin();
 					while (iterator != m_pendingEvents->end()) {
 						sendEvent(*iterator);
 						delete *iterator;
 						iterator++;
 					}
 					m_pendingEvents->clear();
 				}
 			}
 		}
 	} while (packet.length() > 0 && m_inProgressPacket->length() > 0);
 }

 HRESULT STDMETHODCALLTYPE CrossfireServer::registerContext(DWORD threadId, OLECHAR* href) {
 	if (m_port == -1) {
 		return S_FALSE;
 	}

 	static int s_contextCounter = 0;

 	CrossfireContext* context = NULL;
 	std::map<DWORD, CrossfireContext*>::iterator iterator = m_contexts->find(threadId);
 	if (iterator == m_contexts->end()) {
 		context = new CrossfireContext(threadId, this);
 		m_contexts->insert(std::pair<DWORD,CrossfireContext*>(threadId, context));
 	} else {
 		Logger::error("CrossfireServer.registerContext(): a context already exists for thread", threadId);
 		return S_FALSE;
 	}

 	std::wstringstream stream;
 	stream << CONTEXTID_PREAMBLE;
 	stream << threadId;
 	stream << "-";
 	stream << s_contextCounter++;
 	context->setName((wchar_t*)stream.str().c_str());
 	context->setHref(href);
 	return S_OK;
 }

 void CrossfireServer::reset() {
 	m_connection->close();
 	delete m_connection;
 	m_connection = NULL;

 	std::map<DWORD,CrossfireContext*>::iterator iterator = m_contexts->begin();
 	while (iterator != m_contexts->end()) {
 		delete iterator->second;
 		iterator++;
 	}
 	m_contexts->clear();
 	m_currentContext = NULL;
 	m_handshakeReceived = false;
 	m_inProgressPacket->clear();
 	m_lastRequestSeq = -1;
 	m_port = -1;
 }

 void CrossfireServer::sendEvent(CrossfireEvent* eventObj) {
 	/*
 	 * If a request is being processed then events to be sent to
 	 * the client should be queued and sent after the response to
 	 * the request has been sent first.
 	 */
 	if (m_processingRequest) {
 		CrossfireEvent* copy = NULL;
 		eventObj->clone((CrossfirePacket**)&copy);
 		m_pendingEvents->push_back(copy);
 		return;
 	}

 	std::wstring* string = NULL;
 	if (!m_processor->createEventPacket(eventObj, &string)) {
 		Logger::error("CrossfireServer.sendEvent(): Invalid event packet, not sending it");
 		return;
 	}

 	m_connection->send(string->c_str());
 	delete string;
 }

 void CrossfireServer::sendResponse(CrossfireResponse* response) {
 	std::wstring* string = NULL;
 	if (!m_processor->createResponsePacket(response, &string)) {
 		Logger::error("CrossfireServer.sendResponse(): Invalid response packet, not sending it");
 		return;
 	}
 	m_connection->send(string->c_str());
 	delete string;
 }

 HRESULT STDMETHODCALLTYPE CrossfireServer::setCurrentContext(DWORD threadId) {
 	if (m_port == -1) {
 		return S_FALSE;
 	}

 	std::map<DWORD, CrossfireContext*>::iterator iterator = m_contexts->find(threadId);
 	if (iterator == m_contexts->end()) {
 		Logger::error("CrossfireServer.setCurrentContext(): unknown context", threadId);
 		return S_FALSE;
 	}
 	CrossfireContext* context = iterator->second;
 	CrossfireContext* oldContext = m_currentContext;
 	m_currentContext = context;
 	eventContextChanged(context, oldContext);
 	return S_OK;
 }

 void CrossfireServer::setWindowHandle(unsigned long value) {
 	m_windowHandle = value;
 }

 HRESULT STDMETHODCALLTYPE CrossfireServer::start(unsigned int port) {
 	if (m_port != -1) {
 		return S_FALSE;
 	}

 	m_connection = new WindowsSocketConnection(this);
 	if (!m_connection->init(port)) {
 		delete m_connection;
 		return S_FALSE;
 	}
 	m_port = port;
 	m_connection->acceptConnection();
 	return S_OK;
 }

 HRESULT STDMETHODCALLTYPE CrossfireServer::stop() {
 	if (m_port == -1) {
 		return S_FALSE;
 	}

 	eventClosed();
 	reset();
 	return S_OK;
 }

 /* commands */

 bool CrossfireServer::commandListContexts(Value* arguments, Value** _responseBody) {
 	Value contexts;
 	contexts.setType(TYPE_ARRAY);
 	std::map<DWORD,CrossfireContext*>::iterator iterator = m_contexts->begin();
 	while (iterator != m_contexts->end()) {
 		CrossfireContext* context = iterator->second;
 		Value value_context;
 		value_context.addObjectValue(/*KEY_CONTEXTID*/L"context_id", &Value(context->getName()));
 		value_context.addObjectValue(KEY_HREF, &Value(context->getHref()));
 		value_context.addObjectValue(KEY_CURRENT, &Value((bool)(context == m_currentContext)));
 		contexts.addArrayValue(&value_context);
 		iterator++;
 	}

 	Value* result = new Value();
 	result->addObjectValue(KEY_CONTEXTS, &contexts);
 	*_responseBody = result;
 	return true;
 }

 bool CrossfireServer::commandVersion(Value* arguments, Value** _responseBody) {
 	Value* result = new Value();
 	result->addObjectValue(KEY_VERSION, &Value(VERSION_STRING));
 	*_responseBody = result;
 	return true;
 }

 /* events */

 void CrossfireServer::eventClosed() {
 	CrossfireEvent eventObj;
 	eventObj.setName(EVENT_CLOSED);
 	sendEvent(&eventObj);
 }

 void CrossfireServer::eventContextChanged(CrossfireContext* newContext, CrossfireContext* oldContext) {
 	CrossfireEvent eventObj;
 	eventObj.setName(EVENT_CONTEXTCHANGED);
 	eventObj.setContextId(&std::wstring(newContext->getName()));
 	Value data;
 	data.addObjectValue(KEY_NEWHREF, &Value(&std::wstring(newContext->getHref())));
 	if (oldContext) {
 		data.addObjectValue(KEY_HREF, &Value(&std::wstring(oldContext->getHref())));
 	}
 	eventObj.setData(&data);
 	sendEvent(&eventObj);
 }

 void CrossfireServer::eventContextCreated(CrossfireContext* context) {
 	CrossfireEvent eventObj;
 	eventObj.setName(EVENT_CONTEXTCREATED);
 	eventObj.setContextId(&std::wstring(context->getName()));
 	Value data;
 	data.addObjectValue(KEY_HREF, &Value(&std::wstring(context->getHref())));
 	eventObj.setData(&data);
 	sendEvent(&eventObj);
 }

 void CrossfireServer::eventContextDestroyed(CrossfireContext* context) {
 	CrossfireEvent eventObj;
 	eventObj.setName(EVENT_CONTEXTDESTROYED);
 	eventObj.setContextId(&std::wstring(context->getName()));
 	sendEvent(&eventObj);
 }

 void CrossfireServer::eventContextLoaded(CrossfireContext* context) {
 	CrossfireEvent eventObj;
 	eventObj.setName(EVENT_CONTEXTLOADED);
 	eventObj.setContextId(&std::wstring(context->getName()));
 	Value data;
 	data.addObjectValue(KEY_HREF, &Value(&std::wstring(context->getHref())));
 	eventObj.setData(&data);
 	sendEvent(&eventObj);
 }
	/*******************************************************************************
	* Copyright (c) 2011 IBM Corporation 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:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/


	#include "stdafx.h"
	#include "CrossfireServer.h"

	/* initialize statics */
	const wchar_t* CrossfireServer::CONTEXTID_PREAMBLE = L"xfIE::";
	const wchar_t* CrossfireServer::HANDSHAKE = L"CrossfireHandshake\r\n";
	const wchar_t* CrossfireServer::HEADER_CONTENTLENGTH = L"Content-Length:";
	const wchar_t* CrossfireServer::LINEBREAK = L"\r\n";
	const size_t CrossfireServer::LINEBREAK_LENGTH = 2;

	const wchar_t* CrossfireServer::COMMAND_CHANGEBREAKPOINT = L"changebreakpoint";
	const wchar_t* CrossfireServer::COMMAND_CLEARBREAKPOINT = L"clearbreakpoint";
	const wchar_t* CrossfireServer::COMMAND_GETBREAKPOINT = L"getbreakpoint";
	const wchar_t* CrossfireServer::COMMAND_GETBREAKPOINTS = L"getbreakpoints";
	const wchar_t* CrossfireServer::COMMAND_SETBREAKPOINT = L"setbreakpoint";

	/* command: listContexts */
	const wchar_t* CrossfireServer::COMMAND_LISTCONTEXTS = L"listcontexts";
	const wchar_t* CrossfireServer::KEY_CONTEXTS = L"contexts";
	const wchar_t* CrossfireServer::KEY_CURRENT = L"current";

	/* command: version */
	const wchar_t* CrossfireServer::COMMAND_VERSION = L"version";
	const wchar_t* CrossfireServer::KEY_VERSION = L"version";
	const wchar_t* CrossfireServer::VERSION_STRING = L"0.3";

	/* event: closed */
	const wchar_t* CrossfireServer::EVENT_CLOSED = L"closed";

	/* event: onContextChanged */
	const wchar_t* CrossfireServer::EVENT_CONTEXTCHANGED = L"onContextChanged";
	const wchar_t* CrossfireServer::KEY_NEWHREF = L"new-href";

	/* event: onContextCreated */
	const wchar_t* CrossfireServer::EVENT_CONTEXTCREATED = L"onContextCreated";

	/* event: onContextDestroyed */
	const wchar_t* CrossfireServer::EVENT_CONTEXTDESTROYED = L"onContextDestroyed";

	/* event: onContextLoaded */
	const wchar_t* CrossfireServer::EVENT_CONTEXTLOADED = L"onContextLoaded";

	/* shared */
	const wchar_t* CrossfireServer::KEY_HREF = L"href";


	CrossfireServer::CrossfireServer() {
	m_bpManager = new CrossfireBPManager();
	m_connection = NULL;
	m_contexts = new std::map<DWORD, CrossfireContext*>;
	m_currentContext = NULL;
	m_handshakeReceived = false;
	m_inProgressPacket = new std::wstring;
	m_lastRequestSeq = -1;
	m_pendingEvents = new std::vector<CrossfireEvent*>;
	m_port = -1;
	m_processingRequest = false;
	m_processor = new CrossfireProcessor();
	m_windowHandle = 0;
	}

	CrossfireServer::~CrossfireServer() {
	delete m_bpManager;

	std::map<DWORD,CrossfireContext*>::iterator iterator = m_contexts->begin();
	while (iterator != m_contexts->end()) {
	delete iterator->second;
	iterator++;
	}
	delete m_contexts;

	std::vector<CrossfireEvent*>::iterator iterator2 = m_pendingEvents->begin();
	while (iterator2 != m_pendingEvents->end()) {
	if (m_connection) {
	sendEvent(*iterator2);
	}
	delete *iterator2;
	iterator2++;
	}
	delete m_pendingEvents;

	delete m_inProgressPacket;
	delete m_processor;
	if (m_connection) {
	delete m_connection;
	}

	if (m_windowHandle) {
	CComPtr<ICrossfireServerClass> serverClass = NULL;
	HRESULT hr = CoGetClassObject(CLSID_CrossfireServer, CLSCTX_ALL, 0, IID_ICrossfireServerClass, (LPVOID*)&serverClass);
	if (FAILED(hr)) {
	Logger::error("~CrossfireServer: CoGetClassObject() failed", hr);
	return;
	}
	hr = serverClass->RemoveServer(m_windowHandle);
	if (FAILED(hr)) {
	Logger::error("~CrossfireServer: RemoveServer() failed", hr);
	return;
	}
	}
	}

	HRESULT STDMETHODCALLTYPE CrossfireServer::contextCreated(DWORD threadId, OLECHAR* href) {
	if (m_port == -1) {
	return S_FALSE;
	}

	HRESULT hr = registerContext(threadId, href);
	if (SUCCEEDED(hr)) {
	std::map<DWORD, CrossfireContext*>::iterator iterator = m_contexts->find(threadId);
	CrossfireContext* context = iterator->second;
	eventContextCreated(context);
	}
	return hr;
	}

	HRESULT STDMETHODCALLTYPE CrossfireServer::contextDestroyed(DWORD threadId) {
	if (m_port == -1) {
	return S_FALSE;
	}

	std::map<DWORD, CrossfireContext*>::iterator iterator = m_contexts->find(threadId);
	if (iterator == m_contexts->end()) {
	Logger::error("CrossfireServer.contextDestroyed(): unknown context", threadId);
	return S_FALSE;
	}
	CrossfireContext* context = iterator->second;
	eventContextDestroyed(context);
	m_contexts->erase(iterator);
	delete context;
	return S_OK;
	}

	HRESULT STDMETHODCALLTYPE CrossfireServer::contextLoaded(DWORD threadId) {
	if (m_port == -1) {
	return S_FALSE;
	}

	std::map<DWORD, CrossfireContext*>::iterator iterator = m_contexts->find(threadId);
	if (iterator == m_contexts->end()) {
	Logger::error("CrossfireServer.contextLoaded(): unknown context", threadId);
	return S_FALSE;
	}
	CrossfireContext* context = iterator->second;
	eventContextLoaded(context);
	return S_OK;
	}

	void CrossfireServer::disconnected() {
	reset();
	}

	CrossfireBPManager* CrossfireServer::getBreakpointManager() {
	return m_bpManager;
	}

	CrossfireContext* CrossfireServer::getRequestContext(CrossfireRequest* request) {
	std::wstring* contextId = request->getContextId();
	if (!contextId) {
	return NULL;
	}

	wchar_t* searchString = (wchar_t*)contextId->c_str();
	std::map<DWORD,CrossfireContext*>::iterator iterator = m_contexts->begin();
	while (iterator != m_contexts->end()) {
	if (wcscmp(iterator->second->getName(), searchString) == 0) {
	return iterator->second;
	}
	iterator++;
	}
	return NULL;
	}

	HRESULT STDMETHODCALLTYPE CrossfireServer::isActive(boolean* value) {
	*value = m_port != -1;
	return S_OK;
	}

	bool CrossfireServer::performRequest(CrossfireRequest* request) {
	wchar_t* command = request->getName();
	Value* arguments = request->getArguments();
	Value* responseBody = NULL;
	bool success = false;
	if (wcscmp(command, COMMAND_VERSION) == 0) {
	success = commandVersion(arguments, &responseBody);
	} else if (wcscmp(command, COMMAND_CHANGEBREAKPOINT) == 0) {
	CrossfireContext* context = getRequestContext(request);
	IBreakpointTarget* target = context ? (IBreakpointTarget)context : (IBreakpointTarget)m_bpManager;
	success = m_bpManager->commandChangeBreakpoint(arguments, target, &responseBody);
	} else if (wcscmp(command, COMMAND_CLEARBREAKPOINT) == 0) {
	CrossfireContext* context = getRequestContext(request);
	IBreakpointTarget* target = context ? (IBreakpointTarget)context : (IBreakpointTarget)m_bpManager;
	success = m_bpManager->commandClearBreakpoint(arguments, target, &responseBody);
	} else if (wcscmp(command, COMMAND_LISTCONTEXTS) == 0) {
	success = commandListContexts(arguments, &responseBody);
	} else if (wcscmp(command, COMMAND_GETBREAKPOINT) == 0) {
	CrossfireContext* context = getRequestContext(request);
	IBreakpointTarget* target = context ? (IBreakpointTarget)context : (IBreakpointTarget)m_bpManager;
	success = m_bpManager->commandGetBreakpoint(arguments, target, &responseBody);
	} else if (wcscmp(command, COMMAND_GETBREAKPOINTS) == 0) {
	CrossfireContext* context = getRequestContext(request);
	IBreakpointTarget* target = context ? (IBreakpointTarget)context : (IBreakpointTarget)m_bpManager;
	success = m_bpManager->commandGetBreakpoints(arguments, target, &responseBody);
	} else if (wcscmp(command, COMMAND_SETBREAKPOINT) == 0) {
	CrossfireContext* context = getRequestContext(request);
	IBreakpointTarget* target = context ? (IBreakpointTarget)context : (IBreakpointTarget)m_bpManager;
	success = m_bpManager->commandSetBreakpoint(arguments, target, &responseBody);
	} else {
	return false; /* command not handled */
	}

	CrossfireResponse response;
	response.setName(command);
	response.setRequestSeq(request->getSeq());
	response.setRunning(true);
	response.setSuccess(success);
	if (success) {
	response.setBody(responseBody);
	} else {
	Value emptyBody;
	emptyBody.setType(TYPE_OBJECT);
	response.setBody(&emptyBody);
	}
	if (responseBody) {
	delete responseBody;
	}
	sendResponse(&response);
	return true;
	}

	void CrossfireServer::received(wchar_t* msg) {
	if (!m_handshakeReceived) {
	if (wcscmp(msg, HANDSHAKE) == 0) {
	m_handshakeReceived = true;
	m_connection->send(HANDSHAKE);
	} else {
	Logger::error("Crossfire content received before handshake, not processing it");
	}
	return;
	}

	m_inProgressPacket->append(std::wstring(msg));
	std::wstring packet;
	do {
	packet.clear();
	if (m_inProgressPacket->find(HEADER_CONTENTLENGTH) != 0) {
	Logger::error("request packet does not start with 'Content-Length:', not processing it");
	Logger::log(m_inProgressPacket);
	m_inProgressPacket->clear();
	break;
	}

	size_t endIndex = m_inProgressPacket->find(wchar_t('\r'));
	if (endIndex == std::wstring::npos) {
	Logger::error("request packet does not contain '\r', not processing it");
	Logger::log(m_inProgressPacket);
	m_inProgressPacket->clear();
	break;
	}

	size_t headerLength = wcslen(HEADER_CONTENTLENGTH);
	std::wstring lengthString = m_inProgressPacket->substr(headerLength, endIndex - headerLength);
	int lengthValue = _wtoi(lengthString.c_str());
	if (!lengthValue) {
	Logger::error("request packet does not have a valid 'Content-Length' value, not processing it");
	Logger::log(m_inProgressPacket);
	m_inProgressPacket->clear();
	break;
	}

	if (m_inProgressPacket->find(L"\r\n", endIndex) != endIndex) {
	Logger::error("request packet does not follow initial '\\r' with '\\n', not processing it");
	Logger::log(m_inProgressPacket);
	m_inProgressPacket->clear();
	break;
	}

	// TODO for now just skip over "tool:" lines, though these should really be validated

	size_t toolEnd = m_inProgressPacket->find(L"\r\n\r\n", endIndex);
	if (toolEnd == std::wstring::npos) {
	Logger::error("request packet does not contain '\\r\\n\\r\\n' to delimit its header, not processing it");
	Logger::log(m_inProgressPacket);
	m_inProgressPacket->clear();
	break;
	}
	size_t toolsLength = toolEnd - endIndex;
	size_t targetLength = wcslen(HEADER_CONTENTLENGTH) + lengthString.length() + 3 * LINEBREAK_LENGTH + toolsLength + lengthValue;

	if (targetLength <= m_inProgressPacket->length()) {
	packet.assign(m_inProgressPacket->substr(0, targetLength));
	m_inProgressPacket->erase(0, targetLength);
	}

	if (packet.length()) {
	CrossfireRequest* request = NULL;
	if (!m_processor->parseRequestPacket(&packet, &request)) {
	Logger::error("invalid request packet received, not processing it");
	Logger::log(&packet);
	} else {
	unsigned int seq = request->getSeq();
	if (seq <= m_lastRequestSeq) {
	// TODO handle out-of-order packets
	Logger::log("packet received out of sequence, still processing it");
	}
	m_lastRequestSeq = seq;
	m_processingRequest = true;
	if (!performRequest(request)) {
	/*
	* the request's command was not handled by the server,
	* so try to delegate to the specified context, if any
	*/
	CrossfireContext* context = getRequestContext(request);
	if (!context) {
	Logger::error("request command was unknown to the server and a valid context id was not provided, not processing it");
	Logger::log(&packet);
	} else {
	if (!context->performRequest(request)) {
	Logger::error("request command was unknown to the server and to the specified context, not processing it");
	Logger::log(&packet);
	}
	}
	}
	m_processingRequest = false;
	delete request;

	/*
	* Debugger events may have been received in response to the request that was
	* just processed. These events can be sent now that processing of the request
	* is complete.
	*/
	if (m_pendingEvents->size() > 0) {
	// GWG HACK! helps JSDT with stepping
	Logger::error("start sleep");
	Sleep(500);
	Logger::error("end sleep");

	std::vector<CrossfireEvent*>::iterator iterator = m_pendingEvents->begin();
	while (iterator != m_pendingEvents->end()) {
	sendEvent(*iterator);
	delete *iterator;
	iterator++;
	}
	m_pendingEvents->clear();
	}
	}
	}
	} while (packet.length() > 0 && m_inProgressPacket->length() > 0);
	}

	HRESULT STDMETHODCALLTYPE CrossfireServer::registerContext(DWORD threadId, OLECHAR* href) {
	if (m_port == -1) {
	return S_FALSE;
	}

	static int s_contextCounter = 0;

	CrossfireContext* context = NULL;
	std::map<DWORD, CrossfireContext*>::iterator iterator = m_contexts->find(threadId);
	if (iterator == m_contexts->end()) {
	context = new CrossfireContext(threadId, this);
	m_contexts->insert(std::pair<DWORD,CrossfireContext*>(threadId, context));
	} else {
	Logger::error("CrossfireServer.registerContext(): a context already exists for thread", threadId);
	return S_FALSE;
	}

	std::wstringstream stream;
	stream << CONTEXTID_PREAMBLE;
	stream << threadId;
	stream << "-";
	stream << s_contextCounter++;
	context->setName((wchar_t*)stream.str().c_str());
	context->setHref(href);
	return S_OK;
	}

	void CrossfireServer::reset() {
	m_connection->close();
	delete m_connection;
	m_connection = NULL;

	std::map<DWORD,CrossfireContext*>::iterator iterator = m_contexts->begin();
	while (iterator != m_contexts->end()) {
	delete iterator->second;
	iterator++;
	}
	m_contexts->clear();
	m_currentContext = NULL;
	m_handshakeReceived = false;
	m_inProgressPacket->clear();
	m_lastRequestSeq = -1;
	m_port = -1;
	}

	void CrossfireServer::sendEvent(CrossfireEvent* eventObj) {
	/*
	* If a request is being processed then events to be sent to
	* the client should be queued and sent after the response to
	* the request has been sent first.
	*/
	if (m_processingRequest) {
	CrossfireEvent* copy = NULL;
	eventObj->clone((CrossfirePacket**)&copy);
	m_pendingEvents->push_back(copy);
	return;
	}

	std::wstring* string = NULL;
	if (!m_processor->createEventPacket(eventObj, &string)) {
	Logger::error("CrossfireServer.sendEvent(): Invalid event packet, not sending it");
	return;
	}

	m_connection->send(string->c_str());
	delete string;
	}

	void CrossfireServer::sendResponse(CrossfireResponse* response) {
	std::wstring* string = NULL;
	if (!m_processor->createResponsePacket(response, &string)) {
	Logger::error("CrossfireServer.sendResponse(): Invalid response packet, not sending it");
	return;
	}
	m_connection->send(string->c_str());
	delete string;
	}

	HRESULT STDMETHODCALLTYPE CrossfireServer::setCurrentContext(DWORD threadId) {
	if (m_port == -1) {
	return S_FALSE;
	}

	std::map<DWORD, CrossfireContext*>::iterator iterator = m_contexts->find(threadId);
	if (iterator == m_contexts->end()) {
	Logger::error("CrossfireServer.setCurrentContext(): unknown context", threadId);
	return S_FALSE;
	}
	CrossfireContext* context = iterator->second;
	CrossfireContext* oldContext = m_currentContext;
	m_currentContext = context;
	eventContextChanged(context, oldContext);
	return S_OK;
	}

	void CrossfireServer::setWindowHandle(unsigned long value) {
	m_windowHandle = value;
	}

	HRESULT STDMETHODCALLTYPE CrossfireServer::start(unsigned int port) {
	if (m_port != -1) {
	return S_FALSE;
	}

	m_connection = new WindowsSocketConnection(this);
	if (!m_connection->init(port)) {
	delete m_connection;
	return S_FALSE;
	}
	m_port = port;
	m_connection->acceptConnection();
	return S_OK;
	}

	HRESULT STDMETHODCALLTYPE CrossfireServer::stop() {
	if (m_port == -1) {
	return S_FALSE;
	}

	eventClosed();
	reset();
	return S_OK;
	}

	/* commands */

	bool CrossfireServer::commandListContexts(Value* arguments, Value** _responseBody) {
	Value contexts;
	contexts.setType(TYPE_ARRAY);
	std::map<DWORD,CrossfireContext*>::iterator iterator = m_contexts->begin();
	while (iterator != m_contexts->end()) {
	CrossfireContext* context = iterator->second;
	Value value_context;
	value_context.addObjectValue(/KEY_CONTEXTID/L"context_id", &Value(context->getName()));
	value_context.addObjectValue(KEY_HREF, &Value(context->getHref()));
	value_context.addObjectValue(KEY_CURRENT, &Value((bool)(context == m_currentContext)));
	contexts.addArrayValue(&value_context);
	iterator++;
	}

	Value* result = new Value();
	result->addObjectValue(KEY_CONTEXTS, &contexts);
	*_responseBody = result;
	return true;
	}

	bool CrossfireServer::commandVersion(Value* arguments, Value** _responseBody) {
	Value* result = new Value();
	result->addObjectValue(KEY_VERSION, &Value(VERSION_STRING));
	*_responseBody = result;
	return true;
	}

	/* events */

	void CrossfireServer::eventClosed() {
	CrossfireEvent eventObj;
	eventObj.setName(EVENT_CLOSED);
	sendEvent(&eventObj);
	}

	void CrossfireServer::eventContextChanged(CrossfireContext* newContext, CrossfireContext* oldContext) {
	CrossfireEvent eventObj;
	eventObj.setName(EVENT_CONTEXTCHANGED);
	eventObj.setContextId(&std::wstring(newContext->getName()));
	Value data;
	data.addObjectValue(KEY_NEWHREF, &Value(&std::wstring(newContext->getHref())));
	if (oldContext) {
	data.addObjectValue(KEY_HREF, &Value(&std::wstring(oldContext->getHref())));
	}
	eventObj.setData(&data);
	sendEvent(&eventObj);
	}

	void CrossfireServer::eventContextCreated(CrossfireContext* context) {
	CrossfireEvent eventObj;
	eventObj.setName(EVENT_CONTEXTCREATED);
	eventObj.setContextId(&std::wstring(context->getName()));
	Value data;
	data.addObjectValue(KEY_HREF, &Value(&std::wstring(context->getHref())));
	eventObj.setData(&data);
	sendEvent(&eventObj);
	}

	void CrossfireServer::eventContextDestroyed(CrossfireContext* context) {
	CrossfireEvent eventObj;
	eventObj.setName(EVENT_CONTEXTDESTROYED);
	eventObj.setContextId(&std::wstring(context->getName()));
	sendEvent(&eventObj);
	}

	void CrossfireServer::eventContextLoaded(CrossfireContext* context) {
	CrossfireEvent eventObj;
	eventObj.setName(EVENT_CONTEXTLOADED);
	eventObj.setContextId(&std::wstring(context->getName()));
	Value data;
	data.addObjectValue(KEY_HREF, &Value(&std::wstring(context->getHref())));
	eventObj.setData(&data);
	sendEvent(&eventObj);
	}