| Index: src/debug-agent.cc
|
| diff --git a/src/debug-agent.cc b/src/debug-agent.cc
|
| deleted file mode 100644
|
| index 94f334bfe4d15fda302e46b33ec3d6a36e43ce09..0000000000000000000000000000000000000000
|
| --- a/src/debug-agent.cc
|
| +++ /dev/null
|
| @@ -1,481 +0,0 @@
|
| -// Copyright 2012 the V8 project authors. All rights reserved.
|
| -// Use of this source code is governed by a BSD-style license that can be
|
| -// found in the LICENSE file.
|
| -
|
| -#include "v8.h"
|
| -#include "debug.h"
|
| -#include "debug-agent.h"
|
| -#include "platform/socket.h"
|
| -
|
| -namespace v8 {
|
| -namespace internal {
|
| -
|
| -// Public V8 debugger API message handler function. This function just delegates
|
| -// to the debugger agent through it's data parameter.
|
| -void DebuggerAgentMessageHandler(const v8::Debug::Message& message) {
|
| - Isolate* isolate = reinterpret_cast<Isolate*>(message.GetIsolate());
|
| - DebuggerAgent* agent = isolate->debugger_agent_instance();
|
| - ASSERT(agent != NULL);
|
| - agent->DebuggerMessage(message);
|
| -}
|
| -
|
| -
|
| -DebuggerAgent::DebuggerAgent(Isolate* isolate, const char* name, int port)
|
| - : Thread(name),
|
| - isolate_(isolate),
|
| - name_(StrDup(name)),
|
| - port_(port),
|
| - server_(new Socket),
|
| - terminate_(false),
|
| - session_(NULL),
|
| - terminate_now_(0),
|
| - listening_(0) {
|
| - ASSERT(isolate_->debugger_agent_instance() == NULL);
|
| - isolate_->set_debugger_agent_instance(this);
|
| -}
|
| -
|
| -
|
| -DebuggerAgent::~DebuggerAgent() {
|
| - isolate_->set_debugger_agent_instance(NULL);
|
| - delete server_;
|
| -}
|
| -
|
| -
|
| -// Debugger agent main thread.
|
| -void DebuggerAgent::Run() {
|
| - // Allow this socket to reuse port even if still in TIME_WAIT.
|
| - server_->SetReuseAddress(true);
|
| -
|
| - // First bind the socket to the requested port.
|
| - bool bound = false;
|
| - while (!bound && !terminate_) {
|
| - bound = server_->Bind(port_);
|
| -
|
| - // If an error occurred wait a bit before retrying. The most common error
|
| - // would be that the port is already in use so this avoids a busy loop and
|
| - // make the agent take over the port when it becomes free.
|
| - if (!bound) {
|
| - const TimeDelta kTimeout = TimeDelta::FromSeconds(1);
|
| - PrintF("Failed to open socket on port %d, "
|
| - "waiting %d ms before retrying\n", port_,
|
| - static_cast<int>(kTimeout.InMilliseconds()));
|
| - if (!terminate_now_.WaitFor(kTimeout)) {
|
| - if (terminate_) return;
|
| - }
|
| - }
|
| - }
|
| -
|
| - // Accept connections on the bound port.
|
| - while (!terminate_) {
|
| - bool ok = server_->Listen(1);
|
| - listening_.Signal();
|
| - if (ok) {
|
| - // Accept the new connection.
|
| - Socket* client = server_->Accept();
|
| - ok = client != NULL;
|
| - if (ok) {
|
| - // Create and start a new session.
|
| - CreateSession(client);
|
| - }
|
| - }
|
| - }
|
| -}
|
| -
|
| -
|
| -void DebuggerAgent::Shutdown() {
|
| - // Set the termination flag.
|
| - terminate_ = true;
|
| -
|
| - // Signal termination and make the server exit either its listen call or its
|
| - // binding loop. This makes sure that no new sessions can be established.
|
| - terminate_now_.Signal();
|
| - server_->Shutdown();
|
| - Join();
|
| -
|
| - // Close existing session if any.
|
| - CloseSession();
|
| -}
|
| -
|
| -
|
| -void DebuggerAgent::WaitUntilListening() {
|
| - listening_.Wait();
|
| -}
|
| -
|
| -static const char* kCreateSessionMessage =
|
| - "Remote debugging session already active\r\n";
|
| -
|
| -void DebuggerAgent::CreateSession(Socket* client) {
|
| - LockGuard<RecursiveMutex> session_access_guard(&session_access_);
|
| -
|
| - // If another session is already established terminate this one.
|
| - if (session_ != NULL) {
|
| - int len = StrLength(kCreateSessionMessage);
|
| - int res = client->Send(kCreateSessionMessage, len);
|
| - delete client;
|
| - USE(res);
|
| - return;
|
| - }
|
| -
|
| - // Create a new session and hook up the debug message handler.
|
| - session_ = new DebuggerAgentSession(this, client);
|
| - isolate_->debugger()->SetMessageHandler(DebuggerAgentMessageHandler);
|
| - session_->Start();
|
| -}
|
| -
|
| -
|
| -void DebuggerAgent::CloseSession() {
|
| - LockGuard<RecursiveMutex> session_access_guard(&session_access_);
|
| -
|
| - // Terminate the session.
|
| - if (session_ != NULL) {
|
| - session_->Shutdown();
|
| - session_->Join();
|
| - delete session_;
|
| - session_ = NULL;
|
| - }
|
| -}
|
| -
|
| -
|
| -void DebuggerAgent::DebuggerMessage(const v8::Debug::Message& message) {
|
| - LockGuard<RecursiveMutex> session_access_guard(&session_access_);
|
| -
|
| - // Forward the message handling to the session.
|
| - if (session_ != NULL) {
|
| - v8::String::Value val(message.GetJSON());
|
| - session_->DebuggerMessage(Vector<uint16_t>(const_cast<uint16_t*>(*val),
|
| - val.length()));
|
| - }
|
| -}
|
| -
|
| -
|
| -DebuggerAgentSession::~DebuggerAgentSession() {
|
| - delete client_;
|
| -}
|
| -
|
| -
|
| -void DebuggerAgent::OnSessionClosed(DebuggerAgentSession* session) {
|
| - // Don't do anything during termination.
|
| - if (terminate_) {
|
| - return;
|
| - }
|
| -
|
| - // Terminate the session.
|
| - LockGuard<RecursiveMutex> session_access_guard(&session_access_);
|
| - ASSERT(session == session_);
|
| - if (session == session_) {
|
| - session_->Shutdown();
|
| - delete session_;
|
| - session_ = NULL;
|
| - }
|
| -}
|
| -
|
| -
|
| -void DebuggerAgentSession::Run() {
|
| - // Send the hello message.
|
| - bool ok = DebuggerAgentUtil::SendConnectMessage(client_, agent_->name_.get());
|
| - if (!ok) return;
|
| -
|
| - while (true) {
|
| - // Read data from the debugger front end.
|
| - SmartArrayPointer<char> message =
|
| - DebuggerAgentUtil::ReceiveMessage(client_);
|
| -
|
| - const char* msg = message.get();
|
| - bool is_closing_session = (msg == NULL);
|
| -
|
| - if (msg == NULL) {
|
| - // If we lost the connection, then simulate a disconnect msg:
|
| - msg = "{\"seq\":1,\"type\":\"request\",\"command\":\"disconnect\"}";
|
| -
|
| - } else {
|
| - // Check if we're getting a disconnect request:
|
| - const char* disconnectRequestStr =
|
| - "\"type\":\"request\",\"command\":\"disconnect\"}";
|
| - const char* result = strstr(msg, disconnectRequestStr);
|
| - if (result != NULL) {
|
| - is_closing_session = true;
|
| - }
|
| - }
|
| -
|
| - // Convert UTF-8 to UTF-16.
|
| - unibrow::Utf8Decoder<128> decoder(msg, StrLength(msg));
|
| - int utf16_length = decoder.Utf16Length();
|
| - ScopedVector<uint16_t> temp(utf16_length + 1);
|
| - decoder.WriteUtf16(temp.start(), utf16_length);
|
| -
|
| - // Send the request received to the debugger.
|
| - v8::Debug::SendCommand(reinterpret_cast<v8::Isolate*>(agent_->isolate()),
|
| - temp.start(),
|
| - utf16_length,
|
| - NULL);
|
| -
|
| - if (is_closing_session) {
|
| - // Session is closed.
|
| - agent_->OnSessionClosed(this);
|
| - return;
|
| - }
|
| - }
|
| -}
|
| -
|
| -
|
| -void DebuggerAgentSession::DebuggerMessage(Vector<uint16_t> message) {
|
| - DebuggerAgentUtil::SendMessage(client_, message);
|
| -}
|
| -
|
| -
|
| -void DebuggerAgentSession::Shutdown() {
|
| - // Shutdown the socket to end the blocking receive.
|
| - client_->Shutdown();
|
| -}
|
| -
|
| -
|
| -const char* const DebuggerAgentUtil::kContentLength = "Content-Length";
|
| -
|
| -
|
| -SmartArrayPointer<char> DebuggerAgentUtil::ReceiveMessage(Socket* conn) {
|
| - int received;
|
| -
|
| - // Read header.
|
| - int content_length = 0;
|
| - while (true) {
|
| - const int kHeaderBufferSize = 80;
|
| - char header_buffer[kHeaderBufferSize];
|
| - int header_buffer_position = 0;
|
| - char c = '\0'; // One character receive buffer.
|
| - char prev_c = '\0'; // Previous character.
|
| -
|
| - // Read until CRLF.
|
| - while (!(c == '\n' && prev_c == '\r')) {
|
| - prev_c = c;
|
| - received = conn->Receive(&c, 1);
|
| - if (received == 0) {
|
| - PrintF("Error %d\n", Socket::GetLastError());
|
| - return SmartArrayPointer<char>();
|
| - }
|
| -
|
| - // Add character to header buffer.
|
| - if (header_buffer_position < kHeaderBufferSize) {
|
| - header_buffer[header_buffer_position++] = c;
|
| - }
|
| - }
|
| -
|
| - // Check for end of header (empty header line).
|
| - if (header_buffer_position == 2) { // Receive buffer contains CRLF.
|
| - break;
|
| - }
|
| -
|
| - // Terminate header.
|
| - ASSERT(header_buffer_position > 1); // At least CRLF is received.
|
| - ASSERT(header_buffer_position <= kHeaderBufferSize);
|
| - header_buffer[header_buffer_position - 2] = '\0';
|
| -
|
| - // Split header.
|
| - char* key = header_buffer;
|
| - char* value = NULL;
|
| - for (int i = 0; header_buffer[i] != '\0'; i++) {
|
| - if (header_buffer[i] == ':') {
|
| - header_buffer[i] = '\0';
|
| - value = header_buffer + i + 1;
|
| - while (*value == ' ') {
|
| - value++;
|
| - }
|
| - break;
|
| - }
|
| - }
|
| -
|
| - // Check that key is Content-Length.
|
| - if (strcmp(key, kContentLength) == 0) {
|
| - // Get the content length value if present and within a sensible range.
|
| - if (value == NULL || strlen(value) > 7) {
|
| - return SmartArrayPointer<char>();
|
| - }
|
| - for (int i = 0; value[i] != '\0'; i++) {
|
| - // Bail out if illegal data.
|
| - if (value[i] < '0' || value[i] > '9') {
|
| - return SmartArrayPointer<char>();
|
| - }
|
| - content_length = 10 * content_length + (value[i] - '0');
|
| - }
|
| - } else {
|
| - // For now just print all other headers than Content-Length.
|
| - PrintF("%s: %s\n", key, value != NULL ? value : "(no value)");
|
| - }
|
| - }
|
| -
|
| - // Return now if no body.
|
| - if (content_length == 0) {
|
| - return SmartArrayPointer<char>();
|
| - }
|
| -
|
| - // Read body.
|
| - char* buffer = NewArray<char>(content_length + 1);
|
| - received = ReceiveAll(conn, buffer, content_length);
|
| - if (received < content_length) {
|
| - PrintF("Error %d\n", Socket::GetLastError());
|
| - return SmartArrayPointer<char>();
|
| - }
|
| - buffer[content_length] = '\0';
|
| -
|
| - return SmartArrayPointer<char>(buffer);
|
| -}
|
| -
|
| -
|
| -bool DebuggerAgentUtil::SendConnectMessage(Socket* conn,
|
| - const char* embedding_host) {
|
| - static const int kBufferSize = 80;
|
| - char buffer[kBufferSize]; // Sending buffer.
|
| - bool ok;
|
| - int len;
|
| -
|
| - // Send the header.
|
| - len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
|
| - "Type: connect\r\n");
|
| - ok = conn->Send(buffer, len);
|
| - if (!ok) return false;
|
| -
|
| - len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
|
| - "V8-Version: %s\r\n", v8::V8::GetVersion());
|
| - ok = conn->Send(buffer, len);
|
| - if (!ok) return false;
|
| -
|
| - len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
|
| - "Protocol-Version: 1\r\n");
|
| - ok = conn->Send(buffer, len);
|
| - if (!ok) return false;
|
| -
|
| - if (embedding_host != NULL) {
|
| - len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
|
| - "Embedding-Host: %s\r\n", embedding_host);
|
| - ok = conn->Send(buffer, len);
|
| - if (!ok) return false;
|
| - }
|
| -
|
| - len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
|
| - "%s: 0\r\n", kContentLength);
|
| - ok = conn->Send(buffer, len);
|
| - if (!ok) return false;
|
| -
|
| - // Terminate header with empty line.
|
| - len = OS::SNPrintF(Vector<char>(buffer, kBufferSize), "\r\n");
|
| - ok = conn->Send(buffer, len);
|
| - if (!ok) return false;
|
| -
|
| - // No body for connect message.
|
| -
|
| - return true;
|
| -}
|
| -
|
| -
|
| -bool DebuggerAgentUtil::SendMessage(Socket* conn,
|
| - const Vector<uint16_t> message) {
|
| - static const int kBufferSize = 80;
|
| - char buffer[kBufferSize]; // Sending buffer both for header and body.
|
| -
|
| - // Calculate the message size in UTF-8 encoding.
|
| - int utf8_len = 0;
|
| - int previous = unibrow::Utf16::kNoPreviousCharacter;
|
| - for (int i = 0; i < message.length(); i++) {
|
| - uint16_t character = message[i];
|
| - utf8_len += unibrow::Utf8::Length(character, previous);
|
| - previous = character;
|
| - }
|
| -
|
| - // Send the header.
|
| - int len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
|
| - "%s: %d\r\n", kContentLength, utf8_len);
|
| - if (conn->Send(buffer, len) < len) {
|
| - return false;
|
| - }
|
| -
|
| - // Terminate header with empty line.
|
| - len = OS::SNPrintF(Vector<char>(buffer, kBufferSize), "\r\n");
|
| - if (conn->Send(buffer, len) < len) {
|
| - return false;
|
| - }
|
| -
|
| - // Send message body as UTF-8.
|
| - int buffer_position = 0; // Current buffer position.
|
| - previous = unibrow::Utf16::kNoPreviousCharacter;
|
| - for (int i = 0; i < message.length(); i++) {
|
| - // Write next UTF-8 encoded character to buffer.
|
| - uint16_t character = message[i];
|
| - buffer_position +=
|
| - unibrow::Utf8::Encode(buffer + buffer_position, character, previous);
|
| - ASSERT(buffer_position <= kBufferSize);
|
| -
|
| - // Send buffer if full or last character is encoded.
|
| - if (kBufferSize - buffer_position <
|
| - unibrow::Utf16::kMaxExtraUtf8BytesForOneUtf16CodeUnit ||
|
| - i == message.length() - 1) {
|
| - if (unibrow::Utf16::IsLeadSurrogate(character)) {
|
| - const int kEncodedSurrogateLength =
|
| - unibrow::Utf16::kUtf8BytesToCodeASurrogate;
|
| - ASSERT(buffer_position >= kEncodedSurrogateLength);
|
| - len = buffer_position - kEncodedSurrogateLength;
|
| - if (conn->Send(buffer, len) < len) {
|
| - return false;
|
| - }
|
| - for (int i = 0; i < kEncodedSurrogateLength; i++) {
|
| - buffer[i] = buffer[buffer_position + i];
|
| - }
|
| - buffer_position = kEncodedSurrogateLength;
|
| - } else {
|
| - len = buffer_position;
|
| - if (conn->Send(buffer, len) < len) {
|
| - return false;
|
| - }
|
| - buffer_position = 0;
|
| - }
|
| - }
|
| - previous = character;
|
| - }
|
| -
|
| - return true;
|
| -}
|
| -
|
| -
|
| -bool DebuggerAgentUtil::SendMessage(Socket* conn,
|
| - const v8::Handle<v8::String> request) {
|
| - static const int kBufferSize = 80;
|
| - char buffer[kBufferSize]; // Sending buffer both for header and body.
|
| -
|
| - // Convert the request to UTF-8 encoding.
|
| - v8::String::Utf8Value utf8_request(request);
|
| -
|
| - // Send the header.
|
| - int len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
|
| - "Content-Length: %d\r\n", utf8_request.length());
|
| - if (conn->Send(buffer, len) < len) {
|
| - return false;
|
| - }
|
| -
|
| - // Terminate header with empty line.
|
| - len = OS::SNPrintF(Vector<char>(buffer, kBufferSize), "\r\n");
|
| - if (conn->Send(buffer, len) < len) {
|
| - return false;
|
| - }
|
| -
|
| - // Send message body as UTF-8.
|
| - len = utf8_request.length();
|
| - if (conn->Send(*utf8_request, len) < len) {
|
| - return false;
|
| - }
|
| -
|
| - return true;
|
| -}
|
| -
|
| -
|
| -// Receive the full buffer before returning unless an error occours.
|
| -int DebuggerAgentUtil::ReceiveAll(Socket* conn, char* data, int len) {
|
| - int total_received = 0;
|
| - while (total_received < len) {
|
| - int received = conn->Receive(data + total_received, len - total_received);
|
| - if (received == 0) {
|
| - return total_received;
|
| - }
|
| - total_received += received;
|
| - }
|
| - return total_received;
|
| -}
|
| -
|
| -} } // namespace v8::internal
|
|
|