Extend debugger agent protocol with a connect message

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
@@ skipping 132 matching lines @@
   // Terminate the session.
   ScopedLock with(session_access_);
   ASSERT(session == session_);
   if (session == session_) {
     CloseSession();
   }
 }
 
 
 void DebuggerAgentSession::Run() {
+  // Send the hello message.
+  bool ok = DebuggerAgentUtil::SendConnectMessage(client_, *agent_->name_);
+  if (!ok) return;
+
   while (true) {
     // Read data from the debugger front end.
     SmartPointer<char> message = DebuggerAgentUtil::ReceiveMessage(client_);
     if (*message == NULL) {
       // Session is closed.
       agent_->OnSessionClosed(this);
       return;
     }
 
     // Convert UTF-8 to UTF-16.
@@ skipping 82 matching lines @@
         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');
         }
+      } else {
+        // For now just print all other headers than Content-Length.
+        PrintF("%s: %s\n", key, value);
       }
 
       // 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;
       }
     }
   }
 
+  // Return now if no body.
+  if (content_length == 0) {
+    return SmartPointer<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::LastError());
     return SmartPointer<char>();
   }
   buffer[content_length] = '\0';
 
   return SmartPointer<char>(buffer);
 }
 
 
+bool DebuggerAgentUtil::SendConnectMessage(const 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\n");
+  ok = conn->Send(buffer, len);
+  if (!ok) return false;
+
+  len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
+                     "V8-Version: %s\n", v8::V8::GetVersion());
+  ok = conn->Send(buffer, len);
+  if (!ok) return false;
+
+  len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
+                     "Protocol-Version: 1\n");
+  ok = conn->Send(buffer, len);
+  if (!ok) return false;
+
+  if (embedding_host != NULL) {
+    len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
+                       "Embedding-Host: %s\n", embedding_host);
+    ok = conn->Send(buffer, len);
+    if (!ok) return false;
+  }
+
+  len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
+                     "%s: 0\n", kContentLength);
+  ok = conn->Send(buffer, len);
+  if (!ok) return false;
+
+  // Terminate header with empty line.
+  len = OS::SNPrintF(Vector<char>(buffer, kBufferSize), "\n");
+  ok = conn->Send(buffer, len);
+  if (!ok) return false;
+
+  // No body for connect message.
+
+  return true;
+}
+
+
 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);
+                     "%s: %d\n", kContentLength, 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.
@@ skipping 45 matching lines @@
     if (received <= 0) {
       return total_received;
     }
     total_received += received;
   }
   return total_received;
 }
 
 
 } }  // namespace v8::internal