Add support for loading scripts from http

runtime/bin/dartutils.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "bin/dartutils.h"
 
 #include "include/dart_api.h"
 
 #include "platform/assert.h"
 #include "platform/globals.h"
 
 #include "bin/extensions.h"
 #include "bin/directory.h"
 #include "bin/file.h"
 #include "bin/io_buffer.h"
 #include "bin/utils.h"
+#include "bin/socket.h"
 
 namespace dart {
 namespace bin {
 
 const char* DartUtils::original_working_directory = NULL;
 const char* DartUtils::kDartScheme = "dart:";
 const char* DartUtils::kDartExtensionScheme = "dart-ext:";
 const char* DartUtils::kAsyncLibURL = "dart:async";
 const char* DartUtils::kBuiltinLibURL = "dart:builtin";
 const char* DartUtils::kCoreLibURL = "dart:core";
 const char* DartUtils::kIOLibURL = "dart:io";
 const char* DartUtils::kIOLibPatchURL = "dart:io-patch";
 const char* DartUtils::kUriLibURL = "dart:uri";
+const char* DartUtils::kHttpScheme = "http:";
 
 const char* DartUtils::kIdFieldName = "_id";
 
 uint8_t DartUtils::magic_number[] = { 0xf5, 0xf5, 0xdc, 0xdc };
 
 static bool IsWindowsHost() {
 #if defined(TARGET_OS_WINDOWS)
   return true;
 #else  // defined(TARGET_OS_WINDOWS)
   return false;
@@ skipping 95 matching lines @@
 
 
 bool DartUtils::IsDartSchemeURL(const char* url_name) {
   static const intptr_t kDartSchemeLen = strlen(kDartScheme);
   // If the URL starts with "dart:" then it is considered as a special
   // library URL which is handled differently from other URLs.
   return (strncmp(url_name, kDartScheme, kDartSchemeLen) == 0);
 }
 
 
+bool DartUtils::IsHttpSchemeURL(const char* url_name) {
+  static const intptr_t kHttpSchemeLen = strlen(kHttpScheme);
+  return (strncmp(url_name, kHttpScheme, kHttpSchemeLen) == 0);
+}
+
+
 bool DartUtils::IsDartExtensionSchemeURL(const char* url_name) {
   static const intptr_t kDartExtensionSchemeLen = strlen(kDartExtensionScheme);
   // If the URL starts with "dartext:" then it is considered as a special
   // extension library URL which is handled differently from other URLs.
   return
       (strncmp(url_name, kDartExtensionScheme, kDartExtensionSchemeLen) == 0);
 }
 
 
 bool DartUtils::IsDartIOLibURL(const char* url_name) {
@@ skipping 72 matching lines @@
   bool bytes_written = file_stream->WriteFully(buffer, num_bytes);
   ASSERT(bytes_written);
 }
 
 
 void DartUtils::CloseFile(void* stream) {
   delete reinterpret_cast<File*>(stream);
 }
 
 
+// Writes string into socket.

[Ivan Posva, 2013/05/28 18:25:32]

Please document the meaning of the return value.
Another possibility would be to just forward the error code instead of how far
you have written. Making it possible to print the error code in the error
message from where this is called.

[Cutch, 2013/05/28 21:39:55]

I return the error code and print it.

+static intptr_t SocketWriteString(intptr_t socket, const char* str,
+                                  intptr_t len) {
+    int r;
+    intptr_t cursor = 0;
+    do {
+      r = Socket::Write(socket, &str[cursor], len);
+      if (r < 0) {
+        return cursor;
+      }
+      cursor += r;
+      len -= r;
+    } while (len > 0);
+    return cursor;
+}
+
+
+static uint8_t* SocketReadUntilEOF(intptr_t socket, intptr_t* response_len) {
+  const intptr_t kInitialBufferSize = 16 * KB;
+  intptr_t buffer_size = kInitialBufferSize;
+  uint8_t* buffer = reinterpret_cast<uint8_t*>(malloc(buffer_size));
+  ASSERT(buffer != NULL);
+  intptr_t buffer_cursor = 0;
+  do {
+    ssize_t bytes_read = Socket::Read(socket, &buffer[buffer_cursor],
+                                      buffer_size - buffer_cursor - 1);
+    if (bytes_read < 0) {
+      free(buffer);
+      return NULL;
+    }
+
+    buffer_cursor += bytes_read;
+
+    if (bytes_read == 0) {
+      *response_len = buffer_cursor;
+      buffer[buffer_cursor] = '\0';
+      break;
+    }
+
+    // There is still more data to be read, check that we have room in the
+    // buffer for more data.
+    if (buffer_cursor == buffer_size - 1) {
+      // Buffer is full. Increase buffer size.
+      buffer_size *= 2;
+      buffer = reinterpret_cast<uint8_t*>(realloc(buffer, buffer_size));
+      ASSERT(buffer != NULL);
+    }
+  } while (true);
+  return buffer;
+}
+
+
+static bool HttpGetRequestOkay(const char* response) {
+  static const char* kOkayReply = "HTTP/1.0 200 OK";
+  static const intptr_t kOkayReplyLen = strlen(kOkayReply);
+  return (strncmp(response, kOkayReply, kOkayReplyLen) == 0);
+}
+
+
+static const uint8_t* HttpRequestGetPayload(const char* response) {
+  const char* split = strstr(response, "\r\n\r\n");
+  if (split != NULL) {
+    return reinterpret_cast<const uint8_t*>(split+4);
+  }
+  return NULL;
+}
+
+
+// TODO(iposva): Allocate from the zone instead of leaking error string
+// here. On the other hand the binary is about the exit anyway.
+#define SET_ERROR_MSG(error_msg, format, ...)                                  \
+  intptr_t len = snprintf(NULL, 0, format, __VA_ARGS__);                       \
+  char *msg = reinterpret_cast<char*>(malloc(len + 1));                        \
+  snprintf(msg, len + 1, format, __VA_ARGS__);                                 \
+  *error_msg = msg
+
+
+static const uint8_t* HttpGetRequest(const char* host, const char* path,
+                                     int port, intptr_t* response_len,
+                                     const char** error_msg) {
+  OSError* error = NULL;
+  SocketAddresses* addresses = Socket::LookupAddress(host,
+                                                     -1,

[Ivan Posva, 2013/05/28 18:25:32]

Fits on one line?

[Cutch, 2013/05/28 21:39:55]

Done.

+                                                     &error);
+  if (addresses == NULL || addresses->count() == 0) {
+    SET_ERROR_MSG(error_msg, "Unable to resolve %s", host);
+    return NULL;
+  }
+
+  int preferred_address = 0;
+  for (int i = 0; i < addresses->count(); i++) {
+    SocketAddress* address = addresses->GetAt(i);
+    if (address->GetType() == SocketAddress::ADDRESS_LOOPBACK_IP_V4) {
+      // Prefer the IP_V4 loop back.
+      preferred_address = i;
+      break;
+    }
+  }
+
+  RawAddr addr = addresses->GetAt(preferred_address)->addr();
+  intptr_t tcp_client = Socket::Create(addr);
+  if (tcp_client < 0) {
+    SET_ERROR_MSG(error_msg, "Unable to create socket to %s:%d", host, port);
+    return NULL;
+  }
+  Socket::Connect(tcp_client, addr, port);
+  if (tcp_client < 0) {
+    SET_ERROR_MSG(error_msg, "Unable to connect to %s:%d", host, port);
+    return NULL;
+  }
+  // Send get request.
+  {
+    const char* format =
+        "GET %s HTTP/1.0\r\nUser-Agent: Dart VM\r\nHost: %s\r\n\r\n";
+    intptr_t len = snprintf(NULL, 0, format, path, host);
+    char* get_request = reinterpret_cast<char*>(malloc(len + 1));
+    snprintf(get_request, len + 1, format, path, host);
+    intptr_t r = SocketWriteString(tcp_client, get_request, len);
+    free(get_request);
+    if (r != len) {
+      SET_ERROR_MSG(error_msg, "Unable to write to %s:%d", host, port);
+      Socket::Close(tcp_client);
+      return NULL;
+    }
+  }
+  // Consume response.
+  uint8_t* response = SocketReadUntilEOF(tcp_client, response_len);
+  // Close socket.
+  Socket::Close(tcp_client);
+  if (response == NULL) {
+    SET_ERROR_MSG(error_msg, "Unable to read from %s:%d", host, port);
+    return NULL;
+  }
+  if (HttpGetRequestOkay(reinterpret_cast<const char*>(response)) == false) {
+    SET_ERROR_MSG(error_msg, "Invalid HTTP response from %s:%d", host, port);
+    free(response);
+    return NULL;
+  }
+  return response;
+}
+
+
+static Dart_Handle ParseHttpUri(const char* script_uri, const char** host_str,
+                                int64_t* port_int, const char** path_str) {
+  ASSERT(script_uri != NULL);
+  ASSERT(host_str != NULL);
+  ASSERT(port_int != NULL);
+  ASSERT(path_str != NULL);
+  Dart_Handle result;
+  Dart_Handle uri = DartUtils::NewString(script_uri);
+  Dart_Handle builtin_lib =
+      Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
+  Dart_Handle path = DartUtils::PathFromUri(uri, builtin_lib);
+  if (Dart_IsError(path)) {
+    return path;
+  }
+  Dart_Handle host = DartUtils::DomainFromUri(uri, builtin_lib);
+  if (Dart_IsError(host)) {
+    return host;
+  }
+  Dart_Handle port = DartUtils::PortFromUri(uri, builtin_lib);
+  if (Dart_IsError(port)) {
+    return port;
+  }
+  result = Dart_StringToCString(path, path_str);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  result = Dart_StringToCString(host, host_str);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  if (DartUtils::GetInt64Value(port, port_int) == false) {
+    return Dart_Error("Invalid port");
+  }
+  return result;
+}
+
+
+Dart_Handle DartUtils::ReadStringFromHttp(const char* script_uri) {
+  const char* host_str = NULL;
+  int64_t port_int = 0;
+  const char* path_str = NULL;
+  Dart_Handle result = ParseHttpUri(script_uri, &host_str, &port_int,
+                                    &path_str);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  const char* error_msg = NULL;
+  intptr_t len;
+  const uint8_t* text_buffer = HttpGetRequest(host_str, path_str, port_int,
+                                              &len, &error_msg);
+  if (text_buffer == NULL) {
+    return Dart_Error(error_msg);
+  }
+  const uint8_t* payload = HttpRequestGetPayload(
+      reinterpret_cast<const char*>(text_buffer));
+  if (payload == NULL) {
+    return Dart_Error("Invalid HTTP response.");
+  }
+  // Subtract HTTP response from length.
+  len -= (payload-text_buffer);
+  ASSERT(len >= 0);
+  Dart_Handle str = Dart_NewStringFromUTF8(payload, len);
+  return str;
+}
+
+
 static const uint8_t* ReadFileFully(const char* filename,
                                     intptr_t* file_len,
                                     const char** error_msg) {
   void* stream = DartUtils::OpenFile(filename, false);
   if (stream == NULL) {
-    const char* format = "Unable to open file: %s";
-    intptr_t len = snprintf(NULL, 0, format, filename);
-    // TODO(iposva): Allocate from the zone instead of leaking error string
-    // here. On the other hand the binary is about the exit anyway.
-    char* msg = reinterpret_cast<char*>(malloc(len + 1));
-    snprintf(msg, len + 1, format, filename);
-    *error_msg = msg;
+    SET_ERROR_MSG(error_msg, "Unable to open file: %s", filename);
     return NULL;
   }
   *file_len = -1;
   const uint8_t* text_buffer = NULL;
   DartUtils::ReadFile(&text_buffer, file_len, stream);
   if (text_buffer == NULL || *file_len == -1) {
     *error_msg = "Unable to read file contents";
     text_buffer = NULL;
   }
   DartUtils::CloseFile(stream);
@@ skipping 33 matching lines @@
   Dart_Handle dart_args[kNumArgs];
   dart_args[0] = script_uri;
   dart_args[1] = (IsWindowsHost() ? Dart_True() : Dart_False());
   return Dart_Invoke(builtin_lib,
                      NewString("_filePathFromUri"),
                      kNumArgs,
                      dart_args);
 }
 
 
+static Dart_Handle SingleArgDart_Invoke(Dart_Handle arg, Dart_Handle lib,
+                                        const char* method) {
+  const int kNumArgs = 1;
+  Dart_Handle dart_args[kNumArgs];
+  dart_args[0] = arg;
+  return Dart_Invoke(lib, DartUtils::NewString(method), kNumArgs, dart_args);
+}
+
+Dart_Handle DartUtils::PathFromUri(Dart_Handle script_uri,
+                                   Dart_Handle builtin_lib) {
+  return SingleArgDart_Invoke(script_uri, builtin_lib, "_pathFromHttpUri");
+}
+
+
+Dart_Handle DartUtils::DomainFromUri(Dart_Handle script_uri,
+                                     Dart_Handle builtin_lib) {
+  return SingleArgDart_Invoke(script_uri, builtin_lib, "_domainFromHttpUri");
+}
+
+
+Dart_Handle DartUtils::PortFromUri(Dart_Handle script_uri,
+                                   Dart_Handle builtin_lib) {
+  return SingleArgDart_Invoke(script_uri, builtin_lib, "_portFromHttpUri");
+}
+
+
 Dart_Handle DartUtils::ResolveUri(Dart_Handle library_url,
                                   Dart_Handle url,
                                   Dart_Handle builtin_lib) {
   const int kNumArgs = 2;
   Dart_Handle dart_args[kNumArgs];
   dart_args[0] = library_url;
   dart_args[1] = url;
   return Dart_Invoke(
       builtin_lib, NewString("_resolveUri"), kNumArgs, dart_args);
 }
@@ skipping 107 matching lines @@
 }
 
 
 void DartUtils::WriteMagicNumber(File* file) {
   // Write a magic number and version information into the snapshot file.
   bool bytes_written = file->WriteFully(magic_number, sizeof(magic_number));
   ASSERT(bytes_written);
 }
 
 
+Dart_Handle DartUtils::LoadScriptHttp(const char* script_uri,
+                                      Dart_Handle builtin_lib) {
+  Dart_Handle uri = NewString(script_uri);
+  if (Dart_IsError(uri)) {
+    return uri;
+  }
+  const char* host_str = NULL;
+  int64_t port_int = 0;
+  const char* path_str = NULL;
+  Dart_Handle result = ParseHttpUri(script_uri, &host_str, &port_int,
+                                    &path_str);
+  if (Dart_IsError(result)) {
+    return result;
+  }
+  const char* error_msg = NULL;
+  intptr_t len;
+  const uint8_t* text_buffer;
+  text_buffer = HttpGetRequest(host_str, path_str, port_int, &len,
+                               &error_msg);
+  if (text_buffer == NULL) {
+    return Dart_Error(error_msg);
+  }
+  const uint8_t* payload = HttpRequestGetPayload(
+      reinterpret_cast<const char*>(text_buffer));
+  if (payload == NULL) {
+    return Dart_Error("Invalid HTTP response.");
+  }
+  // Subtract HTTP response from length.
+  len -= (payload-text_buffer);
+  ASSERT(len >= 0);
+  // At this point we have received a valid HTTP 200 reply and
+  // payload points at the beginning of the script or snapshot.
+  bool is_snapshot = false;
+  payload = SniffForMagicNumber(payload, &len, &is_snapshot);
+  if (is_snapshot) {
+    return Dart_LoadScriptFromSnapshot(payload, len);
+  } else {
+    Dart_Handle source = Dart_NewStringFromUTF8(payload, len);
+    if (Dart_IsError(source)) {
+      return source;
+    }
+    return Dart_LoadScript(uri, source, 0, 0);
+  }
+}
+
+
 Dart_Handle DartUtils::LoadScript(const char* script_uri,
                                   Dart_Handle builtin_lib) {
+  if (DartUtils::IsHttpSchemeURL(script_uri)) {
+    return LoadScriptHttp(script_uri, builtin_lib);
+  }
   Dart_Handle resolved_script_uri;
   resolved_script_uri = ResolveScriptUri(NewString(script_uri), builtin_lib);
   if (Dart_IsError(resolved_script_uri)) {
     return resolved_script_uri;
   }
   Dart_Handle script_path = DartUtils::FilePathFromUri(resolved_script_uri,
                                                        builtin_lib);
   if (Dart_IsError(script_path)) {
     return script_path;
   }
@@ skipping 19 matching lines @@
     return Dart_LoadScript(resolved_script_uri, source, 0, 0);
   }
 }
 
 
 Dart_Handle DartUtils::LoadSource(CommandLineOptions* url_mapping,
                                   Dart_Handle library,
                                   Dart_Handle url,
                                   Dart_LibraryTag tag,
                                   const char* url_string) {
+  bool is_http_scheme_url = DartUtils::IsHttpSchemeURL(url_string);
   if (url_mapping != NULL && IsDartSchemeURL(url_string)) {
     const char* mapped_url_string = MapLibraryUrl(url_mapping, url_string);
     if (mapped_url_string == NULL) {
       return Dart_Error("Do not know how to load %s", url_string);
     }
     // We have a URL mapping specified, just read the file that the
     // URL mapping specifies and load it.
     url_string = mapped_url_string;
   }
-  // The tag is either an import or a source tag.
-  // Read the file and load it according to the specified tag.
-  Dart_Handle source = DartUtils::ReadStringFromFile(url_string);
+  Dart_Handle source;
+  if (is_http_scheme_url) {
+    // Read the file over http.
+    source = DartUtils::ReadStringFromHttp(url_string);
+  } else {
+    // Read the file.
+    source = DartUtils::ReadStringFromFile(url_string);
+  }
   if (Dart_IsError(source)) {
     return source;  // source contains the error string.
   }
+  // The tag is either an import or a source tag.
+  // Load it according to the specified tag.
   if (tag == kImportTag) {
     // Return library object or an error string.
     return Dart_LoadLibrary(url, source);
   } else if (tag == kSourceTag) {
     return Dart_LoadSource(library, url, source);
   }
   return Dart_Error("wrong tag");
 }
 
 
@@ skipping 312 matching lines @@
       new CObjectString(CObject::NewString(os_error->message()));
   CObjectArray* result = new CObjectArray(CObject::NewArray(3));
   result->SetAt(0, new CObjectInt32(CObject::NewInt32(kOSError)));
   result->SetAt(1, new CObjectInt32(CObject::NewInt32(os_error->code())));
   result->SetAt(2, error_message);
   return result;
 }
 
 }  // namespace bin
 }  // namespace dart