Add V8 debugger agent....

src/debug-agent.cc

+// Copyright 2009 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+#include "v8.h"
+#include "debug-agent.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 uint16_t* message, int length,
+                                 void *data) {
+  reinterpret_cast<DebuggerAgent*>(data)->DebuggerMessage(message, length);
+}
+
+
+// Debugger agent main thread.
+void DebuggerAgent::Run() {
+  // Create a server socket and bind it to the requested port.
+  server_ = OS::CreateSocket();
+  server_->Bind(port_);
+
+  while (!terminate_) {
+    // Listen for new connections.
+    server_->Listen(1);
+
+    // Accept the new connection.
+    Socket* client = server_->Accept();
+
+    // Create and start a new session.
+    CreateSession(client);
+  }
+}
+
+
+void DebuggerAgent::Shutdown() {
+  delete server_;
+}
+
+
+void DebuggerAgent::CreateSession(Socket* client) {
+  ScopedLock with(session_access_);
+
+  // If another session is already established terminate this one.
+  if (session_ != NULL) {
+    static const char* message = "Remote debugging session already active\n";
+
+    client->Send(message, strlen(message));
+    delete client;
+    return;
+  }
+
+  // Create a new session and hook up the debug message handler.
+  session_ = new DebuggerAgentSession(this, client);
+  v8::Debug::SetMessageHandler(DebuggerAgentMessageHandler, this);
+  session_->Start();
+}
+
+
+void DebuggerAgent::DebuggerMessage(const uint16_t* message, int length) {
+  ScopedLock with(session_access_);
+
+  // Forward the message handling to the session.
+  if (session_ != NULL) {
+    session_->DebuggerMessage(Vector<uint16_t>(const_cast<uint16_t*>(message),
+                              length));
+  }
+}
+
+
+void DebuggerAgent::SessionClosed(DebuggerAgentSession* session) {
+  ScopedLock with(session_access_);
+
+  // Terminate the session.
+  ASSERT(session == session_);
+  if (session == session_) {
+    session->Join();
+    delete session;
+    session_ = NULL;
+  }
+}
+
+
+void DebuggerAgentSession::Run() {
+  while (true) {
+    // Read data from the debugger front end.
+    SmartPointer<char> message = DebuggerAgentUtil::ReceiveMessage(client_);
+    if (*message == NULL) {
+      // Session is closed.
+      agent_->SessionClosed(this);
+      return;
+    }
+
+    // Convert UTF-8 to UTF-16.
+    unibrow::Utf8InputBuffer<> buf(*message, strlen(*message));
+    int len = 0;
+    while (buf.has_more()) {
+      buf.GetNext();
+      len++;
+    }
+    int16_t* temp = NewArray<int16_t>(len + 1);
+    buf.Reset(*message, strlen(*message));
+    for (int i = 0; i < len; i++) {
+      temp[i] = buf.GetNext();
+    }
+
+    // Send the request received to the debugger.
+    v8::Debug::SendCommand(reinterpret_cast<const uint16_t *>(temp), len);
+    DeleteArray(temp);
+  }
+}
+
+
+void DebuggerAgentSession::DebuggerMessage(Vector<uint16_t> message) {
+  DebuggerAgentUtil::SendMessage(client_, message);
+}
+
+
+const char* DebuggerAgentUtil::kContentLength = "Content-Length";
+int DebuggerAgentUtil::kContentLengthSize = strlen(kContentLength);
+
+
+SmartPointer<char> DebuggerAgentUtil::ReceiveMessage(const Socket* conn) {
+  int received;
+
+  // Read header.
+  const int kHeaderBufferSize = 80;
+  char header_buffer[kHeaderBufferSize];
+  int header_buffer_position = 0;
+  char c = '\0';  // One character receive buffer.
+  char last_c = '\0';  // Previous character.
+  int content_length = 0;
+  while (!(c == '\n' && last_c == '\n')) {
+    last_c = c;
+    received = conn->Receive(&c, 1);
+    if (received <= 0) {
+      PrintF("Error %d\n", Socket::LastError());
+      return SmartPointer<char>();
+    }
+
+    // Check for end of header line.
+    if (c == '\n') {
+      // Empty header line.
+      if (header_buffer_position == 0) {
+        continue;
+      }
+
+      // Terminate header.
+      ASSERT(header_buffer_position < kHeaderBufferSize);
+      if (header_buffer_position < kHeaderBufferSize) {
+        header_buffer[header_buffer_position] = '\0';
+      }
+
+      // Split header.
+      char* key = header_buffer;
+      char* value = NULL;
+      for (int i = 0; i < header_buffer_position; 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 within a sensible range.
+        if (strlen(value) > 7) {
+          return SmartPointer<char>();
+        }
+        for (int i = 0; value[i] != '\0'; i++) {
+          // Bail out if illegal data.
+          if (value[i] < '0' || value[i] > '9') {
+            return SmartPointer<char>();
+          }
+          content_length = 10 * content_length + (value[i] - '0');
+        }
+      }
+
+      // Start collecting new header.
+      header_buffer_position = 0;
+    } else {
+      // Add character to header buffer (reserve room for terminating '\0').
+      if (header_buffer_position < kHeaderBufferSize - 1) {
+        header_buffer[header_buffer_position++] = c;
+      }
+    }
+  }
+
+  // Read body.
+  char* buffer = NewArray<char>(content_length + 1);
+  received = ReceiveAll(conn, buffer, content_length);
+  if (received < content_length) {
+    PrintF("Error %d\n", Socket::LastError());
+    return SmartPointer<char>();
+  }
+  buffer[content_length] = '\0';
+
+  return SmartPointer<char>(buffer);
+}
+
+
+bool DebuggerAgentUtil::SendMessage(const 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;
+  for (int i = 0; i < message.length(); i++) {
+    utf8_len += unibrow::Utf8::Length(message[i]);
+  }
+
+  // Send the header.
+  int len;
+  len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
+                     "Content-Length: %d\n", utf8_len);
+  conn->Send(buffer, len);
+
+  // Terminate header with empty line.
+  len = OS::SNPrintF(Vector<char>(buffer, kBufferSize), "\n");
+  conn->Send(buffer, len);
+
+  // Send message body as UTF-8.
+  int buffer_position = 0;  // Current buffer position.
+  for (int i = 0; i < message.length(); i++) {
+    // Write next UTF-8 encoded character to buffer.
+    buffer_position +=
+        unibrow::Utf8::Encode(buffer + buffer_position, message[i]);
+    ASSERT(buffer_position < kBufferSize);
+
+    // Send buffer if full or last character is encoded.
+    if (kBufferSize - buffer_position < 3 || i == message.length() - 1) {
+      conn->Send(buffer, buffer_position);
+      buffer_position = 0;
+    }
+  }
+
+  return true;
+}
+
+
+bool DebuggerAgentUtil::SendMessage(const 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;
+  len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
+                     "Content-Length: %d\n", utf8_request.length());
+  conn->Send(buffer, len);
+
+  // Terminate header with empty line.
+  len = OS::SNPrintF(Vector<char>(buffer, kBufferSize), "\n");
+  conn->Send(buffer, len);
+
+  // Send message body as UTF-8.
+  conn->Send(*utf8_request, utf8_request.length());
+
+  return true;
+}
+
+
+// Receive the full buffer before returning unless an error occours.
+int DebuggerAgentUtil::ReceiveAll(const 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