Change the debugger agent protocol to be RFC-822 compilant

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 78 matching lines @@
   // Close existing session if any.
   CloseSession();
 }
 
 
 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";
+    static const char* message = "Remote debugging session already active\r\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();
@@ skipping 85 matching lines @@
 
 
 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>();
-    }
+  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.
 
-    // Check for end of header line.
-    if (c == '\n') {
-      // Empty header line.
-      if (header_buffer_position == 0) {
-        continue;
+    // 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::LastError());
+        return SmartPointer<char>();
       }
 
-      // Terminate header.
-      ASSERT(header_buffer_position < kHeaderBufferSize);
+      // Add character to header buffer.
       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');
-        }
-      } 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;
       }
     }
+
+    // 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 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');
+      }
+    } 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 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");
+                     "Type: connect\r\n");
   ok = conn->Send(buffer, len);
   if (!ok) return false;
 
   len = OS::SNPrintF(Vector<char>(buffer, kBufferSize),
-                     "V8-Version: %s\n", v8::V8::GetVersion());
+                     "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\n");
+                     "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\n", embedding_host);
+                       "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\n", kContentLength);
+                     "%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), "\n");
+  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(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),
-                     "%s: %d\n", kContentLength, utf8_len);
+                     "%s: %d\r\n", kContentLength, utf8_len);
   conn->Send(buffer, len);
 
   // Terminate header with empty line.
-  len = OS::SNPrintF(Vector<char>(buffer, kBufferSize), "\n");
+  len = OS::SNPrintF(Vector<char>(buffer, kBufferSize), "\r\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);
 
@@ skipping 12 matching lines @@
                                     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());
+                     "Content-Length: %d\r\n", utf8_request.length());
   conn->Send(buffer, len);
 
   // Terminate header with empty line.
-  len = OS::SNPrintF(Vector<char>(buffer, kBufferSize), "\n");
+  len = OS::SNPrintF(Vector<char>(buffer, kBufferSize), "\r\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