Fixes #6879

components/devtools/lib.rs

@@ -172,8 +172,8 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                     println!("error: EOF");
                     break 'outer
                 }
-                Err(e) => {
-                    println!("error: {}", e.description());
+                Err(err_msg) => {
+                    println!("error: {}", err_msg);
                     break 'outer
                 }
             }

components/devtools/protocol.rs

@@ -8,12 +8,14 @@
 
 use rustc_serialize::{json, Encodable};
 use rustc_serialize::json::Json;
-use std::io::{self, Read, Write};
+use rustc_serialize::json::ParserError::{IoError, SyntaxError};
+use std::error::Error;
+use std::io::{Read, Write};
 use std::net::TcpStream;
 
 pub trait JsonPacketStream {
     fn write_json_packet<'a, T: Encodable>(&mut self, obj: &T);
-    fn read_json_packet(&mut self) -> io::Result<Option<Json>>;
+    fn read_json_packet(&mut self) -> Result<Option<Json>, String>;
 }
 
 impl JsonPacketStream for TcpStream {
@@ -25,25 +27,38 @@ impl JsonPacketStream for TcpStream {
         self.write_all(s.as_bytes()).unwrap();
     }
 
-    fn read_json_packet<'a>(&mut self) -> io::Result<Option<Json>> {
+    fn read_json_packet<'a>(&mut self) -> Result<Option<Json>, String> {
         // https://wiki.mozilla.org/Remote_Debugging_Protocol_Stream_Transport
         // In short, each JSON packet is [ascii length]:[JSON data of given length]
         let mut buffer = vec!();
         loop {
             let mut buf = [0];
-            let byte = match try!(self.read(&mut buf)) {
-                0 => return Ok(None),  // EOF
-                1 => buf[0],
-                _ => unreachable!(),
+            let byte = match self.read(&mut buf) {
+                Ok(0) => return Ok(None),  // EOF
+                Ok(1) => buf[0],
+                Ok(_) => unreachable!(),
+                Err(e) => return Err(e.description().to_string()),
             };
             match byte {
                 b':' => {
-                    let packet_len_str = String::from_utf8(buffer).unwrap();
-                    let packet_len = u64::from_str_radix(&packet_len_str, 10).unwrap();
+                    let packet_len_str = match String::from_utf8(buffer) {
+                        Ok(packet_len) => packet_len,
+                        Err(_) => return Err("nonvalid UTF8 in packet length".to_string()),
+                    };
+                    let packet_len = match u64::from_str_radix(&packet_len_str, 10) {
+                        Ok(packet_len) => packet_len,
+                        Err(_) => return Err("packet length missing / not parsable".to_string()),
+                    };
                     let mut packet = String::new();
                     self.take(packet_len).read_to_string(&mut packet).unwrap();
                     println!("{}", packet);
-                    return Ok(Some(Json::from_str(&packet).unwrap()))
+                    return match Json::from_str(&packet) {
+                        Ok(json) => Ok(Some(json)),
+                        Err(err) => match err {
+                            IoError(ioerr) => return Err(ioerr.description().to_string()),
+                            SyntaxError(_, l, c) => return Err(format!("syntax at {}:{}", l, c)),
+                        },
+                    };
                 },
                 c => buffer.push(c),
             }