3 files changed, 67 insertions, 0 deletions
diff --git a/src/handlers.h b/src/handlers.h
index decbe59da..715db3483 100644
--- a/src/handlers.h
+++ b/src/handlers.h
@@ -14,5 +14,6 @@ void handle_code_cache(Deno* d, uint32_t cmd_id, const char* filename,
 void handle_timer_start(Deno* d, uint32_t cmd_id, uint32_t timer_id,
                         bool interval, uint32_t delay);
 void handle_timer_clear(Deno* d, uint32_t cmd_id, uint32_t timer_id);
+void handle_read_file_sync(Deno* d, uint32_t cmd_id, const char* filename);
 }  // extern "C"
 #endif  // HANDLERS_H_
diff --git a/src/handlers.rs b/src/handlers.rs
index 480d7b6b8..f0c64e46e 100644
--- a/src/handlers.rs
+++ b/src/handlers.rs
@@ -2,12 +2,17 @@
 use binding;
 use binding::{deno_buf, deno_set_response, DenoC};
 use flatbuffers;
+use flatbuffers::ByteStringOffset;
+use flatbuffers::LabeledUOffsetT;
 use from_c;
+use fs;
 use futures;
 use futures::sync::oneshot;
 use libc::c_char;
+use mem;
 use msg_generated::deno as msg;
 use std::ffi::CStr;
+use std::path::Path;
 
 // Help. Is there a way to do this without macros?
 // Want: fn str_from_ptr(*const c_char) -> &str
@@ -226,6 +231,60 @@ fn send_timer_ready(d: *const DenoC, timer_id: u32, done: bool) {
   );
 }
 
+// Prototype https://github.com/denoland/deno/blob/golang/os.go#L171-L184
+#[no_mangle]
+pub extern "C" fn handle_read_file_sync(
+  d: *const DenoC,
+  cmd_id: u32,
+  filename: *const c_char,
+) {
+  let filename = str_from_ptr!(filename);
+
+  debug!("handle_read_file_sync {}", filename);
+  let result = fs::read_file_sync(Path::new(filename));
+  if result.is_err() {
+    let err = result.unwrap_err();
+    let errmsg = format!("{}", err);
+    reply_error(d, cmd_id, &errmsg);
+    return;
+  }
+
+  // Build the response message. memcpy data into msg.
+  let mut builder = flatbuffers::FlatBufferBuilder::new();
+
+  let vec = result.unwrap();
+  //let data =
+  //  flatbuffers::LabeledUOffsetT::new(builder.push_bytes(vec.as_slice()));
+
+  let data_ = builder.create_byte_vector(vec.as_slice());
+
+  // TODO(ry) This is a hack that can be removed once builder.create_byte_vector
+  // works properly.
+  let data = unsafe {
+    mem::transmute::<LabeledUOffsetT<ByteStringOffset>, LabeledUOffsetT<&[i8]>>(
+      data_,
+    )
+  };
+
+  let msg = msg::CreateReadFileSyncRes(
+    &mut builder,
+    &msg::ReadFileSyncResArgs {
+      data,
+      ..Default::default()
+    },
+  );
+  builder.finish(msg);
+  set_response_base(
+    d,
+    &mut builder,
+    &msg::BaseArgs {
+      msg: Some(msg.union()),
+      msg_type: msg::Any::ReadFileSyncRes,
+      ..Default::default()
+    },
+  );
+}
+
 // TODO(ry) Use Deno instead of DenoC as first arg.
 fn remove_timer(d: *const DenoC, timer_id: u32) {
   let deno = from_c(d);
diff --git a/src/reply.cc b/src/reply.cc
index dada4e168..62abe1364 100644
--- a/src/reply.cc
+++ b/src/reply.cc
@@ -95,6 +95,13 @@ void deno_handle_msg_from_js(Deno* d, deno_buf buf) {
       break;
     }
 
+    case deno::Any_ReadFileSync: {
+      auto msg = base->msg_as_ReadFileSync();
+      auto filename = msg->filename()->c_str();
+      handle_read_file_sync(d, cmd_id, filename);
+      break;
+    }
+
     case deno::Any_NONE:
       CHECK(false && "Got message with msg_type == Any_NONE");
       break;