diff --git a/Cargo.lock b/Cargo.lock
index 723bca872..4837a1a32 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -272,6 +272,7 @@ dependencies = [
"jsonrpc-core 2.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
"jsonrpc-http-server 5.1.0 (git+https://github.com/ethcore/jsonrpc-http-server.git)",
"log 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "mime_guess 1.6.1 (registry+https://github.com/rust-lang/crates.io-index)",
"parity-dapps 0.3.0 (git+https://github.com/ethcore/parity-dapps-rs.git)",
"parity-dapps-builtins 0.5.0 (git+https://github.com/ethcore/parity-dapps-builtins-rs.git)",
"parity-dapps-dao 0.3.0 (git+https://github.com/ethcore/parity-dapps-dao-rs.git)",
diff --git a/dapps/Cargo.toml b/dapps/Cargo.toml
index 219904b4c..f83e0ad11 100644
--- a/dapps/Cargo.toml
+++ b/dapps/Cargo.toml
@@ -27,6 +27,7 @@ parity-dapps-builtins = { git = "https://github.com/ethcore/parity-dapps-builtin
parity-dapps-wallet = { git = "https://github.com/ethcore/parity-dapps-wallet-rs.git", version = "0.5.0", optional = true }
parity-dapps-dao = { git = "https://github.com/ethcore/parity-dapps-dao-rs.git", version = "0.3.0", optional = true }
parity-dapps-makerotc = { git = "https://github.com/ethcore/parity-dapps-makerotc-rs.git", version = "0.2.0", optional = true }
+mime_guess = { version = "1.6.1" }
clippy = { version = "0.0.69", optional = true}
[build-dependencies]
diff --git a/dapps/src/api/api.rs b/dapps/src/api/api.rs
index c460dcf20..95b01d442 100644
--- a/dapps/src/api/api.rs
+++ b/dapps/src/api/api.rs
@@ -15,7 +15,7 @@
// along with Parity. If not, see .
use std::sync::Arc;
-use endpoint::{Endpoint, Endpoints, Handler, EndpointPath};
+use endpoint::{Endpoint, Endpoints, EndpointInfo, Handler, EndpointPath};
use api::response::as_json;
@@ -23,8 +23,8 @@ pub struct RestApi {
endpoints: Arc,
}
-#[derive(Debug, PartialEq, Serialize)]
-struct App {
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct App {
pub id: String,
pub name: String,
pub description: String,
@@ -34,6 +34,19 @@ struct App {
pub icon_url: String,
}
+impl App {
+ fn from_info(id: &str, info: &EndpointInfo) -> Self {
+ App {
+ id: id.to_owned(),
+ name: info.name.to_owned(),
+ description: info.description.to_owned(),
+ version: info.version.to_owned(),
+ author: info.author.to_owned(),
+ icon_url: info.icon_url.to_owned(),
+ }
+ }
+}
+
impl RestApi {
pub fn new(endpoints: Arc) -> Box {
Box::new(RestApi {
@@ -43,14 +56,7 @@ impl RestApi {
fn list_apps(&self) -> Vec {
self.endpoints.iter().filter_map(|(ref k, ref e)| {
- e.info().map(|ref info| App {
- id: k.to_owned().clone(),
- name: info.name.to_owned(),
- description: info.description.to_owned(),
- version: info.version.to_owned(),
- author: info.author.to_owned(),
- icon_url: info.icon_url.to_owned(),
- })
+ e.info().map(|ref info| App::from_info(k, info))
}).collect()
}
}
diff --git a/dapps/src/api/mod.rs.in b/dapps/src/api/mod.rs.in
index 0eff6b397..a069c06b0 100644
--- a/dapps/src/api/mod.rs.in
+++ b/dapps/src/api/mod.rs.in
@@ -18,3 +18,4 @@ mod api;
mod response;
pub use self::api::RestApi;
+pub use self::api::App;
diff --git a/dapps/src/apps/fs.rs b/dapps/src/apps/fs.rs
new file mode 100644
index 000000000..fa3b0ab4c
--- /dev/null
+++ b/dapps/src/apps/fs.rs
@@ -0,0 +1,116 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity. If not, see .
+
+use serde_json;
+use std::io;
+use std::io::Read;
+use std::fs;
+use std::path::PathBuf;
+use page::LocalPageEndpoint;
+use endpoint::{Endpoints, EndpointInfo};
+use api::App;
+
+struct LocalDapp {
+ id: String,
+ path: PathBuf,
+ info: EndpointInfo,
+}
+
+fn local_dapps(dapps_path: String) -> Vec {
+ let files = fs::read_dir(dapps_path.as_str());
+ if let Err(e) = files {
+ warn!(target: "dapps", "Unable to load local dapps from: {}. Reason: {:?}", dapps_path, e);
+ return vec![];
+ }
+
+ let files = files.expect("Check is done earlier");
+ files.map(|dir| {
+ let entry = try!(dir);
+ let file_type = try!(entry.file_type());
+
+ // skip files
+ if file_type.is_file() {
+ return Err(io::Error::new(io::ErrorKind::NotFound, "Not a file"));
+ }
+
+ // take directory name and path
+ entry.file_name().into_string()
+ .map(|name| (name, entry.path()))
+ .map_err(|e| {
+ info!(target: "dapps", "Unable to load dapp: {:?}. Reason: {:?}", entry.path(), e);
+ io::Error::new(io::ErrorKind::NotFound, "Invalid name")
+ })
+ })
+ .filter_map(|m| {
+ if let Err(ref e) = m {
+ debug!(target: "dapps", "Ignoring local dapp: {:?}", e);
+ }
+ m.ok()
+ })
+ .map(|(name, path)| {
+ // try to get manifest file
+ let info = read_manifest(&name, path.clone());
+ LocalDapp {
+ id: name,
+ path: path,
+ info: info,
+ }
+ })
+ .collect()
+}
+
+fn read_manifest(name: &str, mut path: PathBuf) -> EndpointInfo {
+ path.push("manifest.json");
+
+ fs::File::open(path.clone())
+ .map_err(|e| format!("{:?}", e))
+ .and_then(|mut f| {
+ // Reat file
+ let mut s = String::new();
+ try!(f.read_to_string(&mut s).map_err(|e| format!("{:?}", e)));
+ // Try to deserialize manifest
+ serde_json::from_str::(&s).map_err(|e| format!("{:?}", e))
+ })
+ .map(|app| EndpointInfo {
+ name: app.name,
+ description: app.description,
+ version: app.version,
+ author: app.author,
+ icon_url: app.icon_url,
+ })
+ .unwrap_or_else(|e| {
+ warn!(target: "dapps", "Cannot read manifest file at: {:?}. Error: {:?}", path, e);
+
+ EndpointInfo {
+ name: name.into(),
+ description: name.into(),
+ version: "0.0.0".into(),
+ author: "?".into(),
+ icon_url: "icon.png".into(),
+ }
+ })
+}
+
+pub fn local_endpoints(dapps_path: String) -> Endpoints {
+ let mut pages = Endpoints::new();
+ for dapp in local_dapps(dapps_path) {
+ pages.insert(
+ dapp.id,
+ Box::new(LocalPageEndpoint::new(dapp.path, dapp.info))
+ );
+ }
+ pages
+}
diff --git a/dapps/src/apps.rs b/dapps/src/apps/mod.rs
similarity index 93%
rename from dapps/src/apps.rs
rename to dapps/src/apps/mod.rs
index 130b20fb9..7f849cf65 100644
--- a/dapps/src/apps.rs
+++ b/dapps/src/apps/mod.rs
@@ -19,10 +19,11 @@ use page::PageEndpoint;
use proxypac::ProxyPac;
use parity_dapps::WebApp;
+mod fs;
+
extern crate parity_dapps_status;
extern crate parity_dapps_builtins;
-
pub const DAPPS_DOMAIN : &'static str = ".parity";
pub const RPC_PATH : &'static str = "rpc";
pub const API_PATH : &'static str = "api";
@@ -36,22 +37,24 @@ pub fn utils() -> Box {
Box::new(PageEndpoint::with_prefix(parity_dapps_builtins::App::default(), UTILS_PATH.to_owned()))
}
-pub fn all_endpoints() -> Endpoints {
- let mut pages = Endpoints::new();
- pages.insert("proxy".into(), ProxyPac::boxed());
-
+pub fn all_endpoints(dapps_path: String) -> Endpoints {
+ // fetch fs dapps at first to avoid overwriting builtins
+ let mut pages = fs::local_endpoints(dapps_path);
// Home page needs to be safe embed
// because we use Cross-Origin LocalStorage.
// TODO [ToDr] Account naming should be moved to parity.
pages.insert("home".into(), Box::new(
PageEndpoint::new_safe_to_embed(parity_dapps_builtins::App::default())
));
+ pages.insert("proxy".into(), ProxyPac::boxed());
insert::(&mut pages, "status");
insert::(&mut pages, "parity");
+ // Optional dapps
wallet_page(&mut pages);
daodapp_page(&mut pages);
makerotc_page(&mut pages);
+
pages
}
diff --git a/dapps/src/endpoint.rs b/dapps/src/endpoint.rs
index 28ca6ea11..592bc7f8f 100644
--- a/dapps/src/endpoint.rs
+++ b/dapps/src/endpoint.rs
@@ -30,17 +30,17 @@ pub struct EndpointPath {
pub port: u16,
}
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
pub struct EndpointInfo {
- pub name: &'static str,
- pub description: &'static str,
- pub version: &'static str,
- pub author: &'static str,
- pub icon_url: &'static str,
+ pub name: String,
+ pub description: String,
+ pub version: String,
+ pub author: String,
+ pub icon_url: String,
}
pub trait Endpoint : Send + Sync {
- fn info(&self) -> Option { None }
+ fn info(&self) -> Option<&EndpointInfo> { None }
fn to_handler(&self, path: EndpointPath) -> Box>;
}
diff --git a/dapps/src/lib.rs b/dapps/src/lib.rs
index 231e7b080..a7fbd5963 100644
--- a/dapps/src/lib.rs
+++ b/dapps/src/lib.rs
@@ -53,6 +53,7 @@ extern crate jsonrpc_core;
extern crate jsonrpc_http_server;
extern crate parity_dapps;
extern crate ethcore_rpc;
+extern crate mime_guess;
mod endpoint;
mod apps;
@@ -73,6 +74,7 @@ static DAPPS_DOMAIN : &'static str = ".parity";
/// Webapps HTTP+RPC server build.
pub struct ServerBuilder {
+ dapps_path: String,
handler: Arc,
}
@@ -84,8 +86,9 @@ impl Extendable for ServerBuilder {
impl ServerBuilder {
/// Construct new dapps server
- pub fn new() -> Self {
+ pub fn new(dapps_path: String) -> Self {
ServerBuilder {
+ dapps_path: dapps_path,
handler: Arc::new(IoHandler::new())
}
}
@@ -93,13 +96,13 @@ impl ServerBuilder {
/// Asynchronously start server with no authentication,
/// returns result with `Server` handle on success or an error.
pub fn start_unsecure_http(&self, addr: &SocketAddr) -> Result {
- Server::start_http(addr, NoAuth, self.handler.clone())
+ Server::start_http(addr, NoAuth, self.handler.clone(), self.dapps_path.clone())
}
/// Asynchronously start server with `HTTP Basic Authentication`,
/// return result with `Server` handle on success or an error.
pub fn start_basic_auth_http(&self, addr: &SocketAddr, username: &str, password: &str) -> Result {
- Server::start_http(addr, HttpBasicAuth::single_user(username, password), self.handler.clone())
+ Server::start_http(addr, HttpBasicAuth::single_user(username, password), self.handler.clone(), self.dapps_path.clone())
}
}
@@ -110,10 +113,10 @@ pub struct Server {
}
impl Server {
- fn start_http(addr: &SocketAddr, authorization: A, handler: Arc) -> Result {
+ fn start_http(addr: &SocketAddr, authorization: A, handler: Arc, dapps_path: String) -> Result {
let panic_handler = Arc::new(Mutex::new(None));
let authorization = Arc::new(authorization);
- let endpoints = Arc::new(apps::all_endpoints());
+ let endpoints = Arc::new(apps::all_endpoints(dapps_path));
let special = Arc::new({
let mut special = HashMap::new();
special.insert(router::SpecialEndpoint::Rpc, rpc::rpc(handler, panic_handler.clone()));
diff --git a/dapps/src/page/builtin.rs b/dapps/src/page/builtin.rs
new file mode 100644
index 000000000..1c7ca32d4
--- /dev/null
+++ b/dapps/src/page/builtin.rs
@@ -0,0 +1,154 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity. If not, see .
+
+use page::handler;
+use std::sync::Arc;
+use endpoint::{Endpoint, EndpointInfo, EndpointPath, Handler};
+use parity_dapps::{WebApp, File, Info};
+
+pub struct PageEndpoint {
+ /// Content of the files
+ pub app: Arc,
+ /// Prefix to strip from the path (when `None` deducted from `app_id`)
+ pub prefix: Option,
+ /// Safe to be loaded in frame by other origin. (use wisely!)
+ safe_to_embed: bool,
+ info: EndpointInfo,
+}
+
+impl PageEndpoint {
+ /// Creates new `PageEndpoint` for builtin (compile time) Dapp.
+ pub fn new(app: T) -> Self {
+ let info = app.info();
+ PageEndpoint {
+ app: Arc::new(app),
+ prefix: None,
+ safe_to_embed: false,
+ info: EndpointInfo::from(info),
+ }
+ }
+
+ /// Create new `PageEndpoint` and specify prefix that should be removed before looking for a file.
+ /// It's used only for special endpoints (i.e. `/parity-utils/`)
+ /// So `/parity-utils/inject.js` will be resolved to `/inject.js` is prefix is set.
+ pub fn with_prefix(app: T, prefix: String) -> Self {
+ let info = app.info();
+ PageEndpoint {
+ app: Arc::new(app),
+ prefix: Some(prefix),
+ safe_to_embed: false,
+ info: EndpointInfo::from(info),
+ }
+ }
+
+ /// Creates new `PageEndpoint` which can be safely used in iframe
+ /// even from different origin. It might be dangerous (clickjacking).
+ /// Use wisely!
+ pub fn new_safe_to_embed(app: T) -> Self {
+ let info = app.info();
+ PageEndpoint {
+ app: Arc::new(app),
+ prefix: None,
+ safe_to_embed: true,
+ info: EndpointInfo::from(info),
+ }
+ }
+}
+
+impl Endpoint for PageEndpoint {
+
+ fn info(&self) -> Option<&EndpointInfo> {
+ Some(&self.info)
+ }
+
+ fn to_handler(&self, path: EndpointPath) -> Box {
+ Box::new(handler::PageHandler {
+ app: BuiltinDapp::new(self.app.clone()),
+ prefix: self.prefix.clone(),
+ path: path,
+ file: None,
+ safe_to_embed: self.safe_to_embed,
+ })
+ }
+}
+
+impl From for EndpointInfo {
+ fn from(info: Info) -> Self {
+ EndpointInfo {
+ name: info.name.into(),
+ description: info.description.into(),
+ author: info.author.into(),
+ icon_url: info.icon_url.into(),
+ version: info.version.into(),
+ }
+ }
+}
+
+struct BuiltinDapp {
+ app: Arc,
+}
+
+impl BuiltinDapp {
+ fn new(app: Arc) -> Self {
+ BuiltinDapp {
+ app: app,
+ }
+ }
+}
+
+impl handler::Dapp for BuiltinDapp {
+ type DappFile = BuiltinDappFile;
+
+ fn file(&self, path: &str) -> Option {
+ self.app.file(path).map(|_| {
+ BuiltinDappFile {
+ app: self.app.clone(),
+ path: path.into(),
+ write_pos: 0,
+ }
+ })
+ }
+}
+
+struct BuiltinDappFile {
+ app: Arc,
+ path: String,
+ write_pos: usize,
+}
+
+impl BuiltinDappFile {
+ fn file(&self) -> &File {
+ self.app.file(&self.path).expect("Check is done when structure is created.")
+ }
+}
+
+impl handler::DappFile for BuiltinDappFile {
+ fn content_type(&self) -> &str {
+ self.file().content_type
+ }
+
+ fn is_drained(&self) -> bool {
+ self.write_pos == self.file().content.len()
+ }
+
+ fn next_chunk(&mut self) -> &[u8] {
+ &self.file().content[self.write_pos..]
+ }
+
+ fn bytes_written(&mut self, bytes: usize) {
+ self.write_pos += bytes;
+ }
+}
diff --git a/dapps/src/page/handler.rs b/dapps/src/page/handler.rs
new file mode 100644
index 000000000..5167c85c8
--- /dev/null
+++ b/dapps/src/page/handler.rs
@@ -0,0 +1,207 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity. If not, see .
+
+use std::io::Write;
+use hyper::header;
+use hyper::server;
+use hyper::uri::RequestUri;
+use hyper::net::HttpStream;
+use hyper::status::StatusCode;
+use hyper::{Decoder, Encoder, Next};
+use endpoint::EndpointPath;
+
+/// Represents a file that can be sent to client.
+/// Implementation should keep track of bytes already sent internally.
+pub trait DappFile: Send {
+ /// Returns a content-type of this file.
+ fn content_type(&self) -> &str;
+
+ /// Checks if all bytes from that file were written.
+ fn is_drained(&self) -> bool;
+
+ /// Fetch next chunk to write to the client.
+ fn next_chunk(&mut self) -> &[u8];
+
+ /// How many files have been written to the client.
+ fn bytes_written(&mut self, bytes: usize);
+}
+
+/// Dapp as a (dynamic) set of files.
+pub trait Dapp: Send + 'static {
+ /// File type
+ type DappFile: DappFile;
+
+ /// Returns file under given path.
+ fn file(&self, path: &str) -> Option;
+}
+
+/// A handler for a single webapp.
+/// Resolves correct paths and serves as a plumbing code between
+/// hyper server and dapp.
+pub struct PageHandler {
+ /// A Dapp.
+ pub app: T,
+ /// File currently being served (or `None` if file does not exist).
+ pub file: Option,
+ /// Optional prefix to strip from path.
+ pub prefix: Option,
+ /// Requested path.
+ pub path: EndpointPath,
+ /// Flag indicating if the file can be safely embeded (put in iframe).
+ pub safe_to_embed: bool,
+}
+
+impl PageHandler {
+ fn extract_path(&self, path: &str) -> String {
+ let app_id = &self.path.app_id;
+ let prefix = "/".to_owned() + self.prefix.as_ref().unwrap_or(app_id);
+ let prefix_with_slash = prefix.clone() + "/";
+ let query_pos = path.find('?').unwrap_or_else(|| path.len());
+
+ // Index file support
+ match path == "/" || path == &prefix || path == &prefix_with_slash {
+ true => "index.html".to_owned(),
+ false => if path.starts_with(&prefix_with_slash) {
+ path[prefix_with_slash.len()..query_pos].to_owned()
+ } else if path.starts_with("/") {
+ path[1..query_pos].to_owned()
+ } else {
+ path[0..query_pos].to_owned()
+ }
+ }
+ }
+}
+
+impl server::Handler for PageHandler {
+ fn on_request(&mut self, req: server::Request) -> Next {
+ self.file = match *req.uri() {
+ RequestUri::AbsolutePath(ref path) => {
+ self.app.file(&self.extract_path(path))
+ },
+ RequestUri::AbsoluteUri(ref url) => {
+ self.app.file(&self.extract_path(url.path()))
+ },
+ _ => None,
+ };
+ Next::write()
+ }
+
+ fn on_request_readable(&mut self, _decoder: &mut Decoder) -> Next {
+ Next::write()
+ }
+
+ fn on_response(&mut self, res: &mut server::Response) -> Next {
+ if let Some(ref f) = self.file {
+ res.set_status(StatusCode::Ok);
+ res.headers_mut().set(header::ContentType(f.content_type().parse().unwrap()));
+ if !self.safe_to_embed {
+ res.headers_mut().set_raw("X-Frame-Options", vec![b"SAMEORIGIN".to_vec()]);
+ }
+ Next::write()
+ } else {
+ res.set_status(StatusCode::NotFound);
+ Next::write()
+ }
+ }
+
+ fn on_response_writable(&mut self, encoder: &mut Encoder) -> Next {
+ match self.file {
+ None => Next::end(),
+ Some(ref f) if f.is_drained() => Next::end(),
+ Some(ref mut f) => match encoder.write(f.next_chunk()) {
+ Ok(bytes) => {
+ f.bytes_written(bytes);
+ Next::write()
+ },
+ Err(e) => match e.kind() {
+ ::std::io::ErrorKind::WouldBlock => Next::write(),
+ _ => Next::end(),
+ },
+ }
+ }
+ }
+}
+
+
+
+#[cfg(test)]
+mod test {
+ use super::*;
+
+ pub struct TestWebAppFile;
+
+ impl DappFile for TestWebAppFile {
+ fn content_type(&self) -> &str {
+ unimplemented!()
+ }
+
+ fn is_drained(&self) -> bool {
+ unimplemented!()
+ }
+
+ fn next_chunk(&mut self) -> &[u8] {
+ unimplemented!()
+ }
+
+ fn bytes_written(&mut self, _bytes: usize) {
+ unimplemented!()
+ }
+ }
+
+ #[derive(Default)]
+ pub struct TestWebapp;
+
+ impl Dapp for TestWebapp {
+ type DappFile = TestWebAppFile;
+
+ fn file(&self, _path: &str) -> Option {
+ None
+ }
+ }
+}
+
+#[test]
+fn should_extract_path_with_appid() {
+
+ // given
+ let path1 = "/";
+ let path2= "/test.css";
+ let path3 = "/app/myfile.txt";
+ let path4 = "/app/myfile.txt?query=123";
+ let page_handler = PageHandler {
+ app: test::TestWebapp,
+ prefix: None,
+ path: EndpointPath {
+ app_id: "app".to_owned(),
+ host: "".to_owned(),
+ port: 8080
+ },
+ file: None,
+ safe_to_embed: true,
+ };
+
+ // when
+ let res1 = page_handler.extract_path(path1);
+ let res2 = page_handler.extract_path(path2);
+ let res3 = page_handler.extract_path(path3);
+ let res4 = page_handler.extract_path(path4);
+
+ // then
+ assert_eq!(&res1, "index.html");
+ assert_eq!(&res2, "test.css");
+ assert_eq!(&res3, "myfile.txt");
+ assert_eq!(&res4, "myfile.txt");
+}
diff --git a/dapps/src/page/local.rs b/dapps/src/page/local.rs
new file mode 100644
index 000000000..52e32bf5e
--- /dev/null
+++ b/dapps/src/page/local.rs
@@ -0,0 +1,118 @@
+// Copyright 2015, 2016 Ethcore (UK) Ltd.
+// This file is part of Parity.
+
+// Parity is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Parity is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Parity. If not, see .
+
+use mime_guess;
+use std::io::{Seek, Read, SeekFrom};
+use std::fs;
+use std::path::PathBuf;
+use page::handler;
+use endpoint::{Endpoint, EndpointInfo, EndpointPath, Handler};
+
+pub struct LocalPageEndpoint {
+ path: PathBuf,
+ info: EndpointInfo,
+}
+
+impl LocalPageEndpoint {
+ pub fn new(path: PathBuf, info: EndpointInfo) -> Self {
+ LocalPageEndpoint {
+ path: path,
+ info: info,
+ }
+ }
+}
+
+impl Endpoint for LocalPageEndpoint {
+ fn info(&self) -> Option<&EndpointInfo> {
+ Some(&self.info)
+ }
+
+ fn to_handler(&self, path: EndpointPath) -> Box {
+ Box::new(handler::PageHandler {
+ app: LocalDapp::new(self.path.clone()),
+ prefix: None,
+ path: path,
+ file: None,
+ safe_to_embed: false,
+ })
+ }
+}
+
+struct LocalDapp {
+ path: PathBuf,
+}
+
+impl LocalDapp {
+ fn new(path: PathBuf) -> Self {
+ LocalDapp {
+ path: path
+ }
+ }
+}
+
+impl handler::Dapp for LocalDapp {
+ type DappFile = LocalFile;
+
+ fn file(&self, file_path: &str) -> Option {
+ let mut path = self.path.clone();
+ for part in file_path.split('/') {
+ path.push(part);
+ }
+ // Check if file exists
+ fs::File::open(path.clone()).ok().map(|file| {
+ let content_type = mime_guess::guess_mime_type(path);
+ let len = file.metadata().ok().map_or(0, |meta| meta.len());
+ LocalFile {
+ content_type: content_type.to_string(),
+ buffer: [0; 4096],
+ file: file,
+ pos: 0,
+ len: len,
+ }
+ })
+ }
+}
+
+struct LocalFile {
+ content_type: String,
+ buffer: [u8; 4096],
+ file: fs::File,
+ len: u64,
+ pos: u64,
+}
+
+impl handler::DappFile for LocalFile {
+ fn content_type(&self) -> &str {
+ &self.content_type
+ }
+
+ fn is_drained(&self) -> bool {
+ self.pos == self.len
+ }
+
+ fn next_chunk(&mut self) -> &[u8] {
+ let _ = self.file.seek(SeekFrom::Start(self.pos));
+ if let Ok(n) = self.file.read(&mut self.buffer) {
+ &self.buffer[0..n]
+ } else {
+ &self.buffer[0..0]
+ }
+ }
+
+ fn bytes_written(&mut self, bytes: usize) {
+ self.pos += bytes as u64;
+ }
+}
diff --git a/dapps/src/page/mod.rs b/dapps/src/page/mod.rs
index 819988310..349c979c7 100644
--- a/dapps/src/page/mod.rs
+++ b/dapps/src/page/mod.rs
@@ -14,216 +14,11 @@
// You should have received a copy of the GNU General Public License
// along with Parity. If not, see .
-use std::sync::Arc;
-use std::io::Write;
-use hyper::uri::RequestUri;
-use hyper::server;
-use hyper::header;
-use hyper::status::StatusCode;
-use hyper::net::HttpStream;
-use hyper::{Decoder, Encoder, Next};
-use endpoint::{Endpoint, EndpointInfo, EndpointPath};
-use parity_dapps::{WebApp, Info};
-pub struct PageEndpoint {
- /// Content of the files
- pub app: Arc,
- /// Prefix to strip from the path (when `None` deducted from `app_id`)
- pub prefix: Option,
- /// Safe to be loaded in frame by other origin. (use wisely!)
- safe_to_embed: bool,
-}
+mod builtin;
+mod local;
+mod handler;
-impl PageEndpoint {
- pub fn new(app: T) -> Self {
- PageEndpoint {
- app: Arc::new(app),
- prefix: None,
- safe_to_embed: false,
- }
- }
+pub use self::local::LocalPageEndpoint;
+pub use self::builtin::PageEndpoint;
- pub fn with_prefix(app: T, prefix: String) -> Self {
- PageEndpoint {
- app: Arc::new(app),
- prefix: Some(prefix),
- safe_to_embed: false,
- }
- }
-
- /// Creates new `PageEndpoint` which can be safely used in iframe
- /// even from different origin. It might be dangerous (clickjacking).
- /// Use wisely!
- pub fn new_safe_to_embed(app: T) -> Self {
- PageEndpoint {
- app: Arc::new(app),
- prefix: None,
- safe_to_embed: true,
- }
- }
-}
-
-impl Endpoint for PageEndpoint {
-
- fn info(&self) -> Option {
- Some(EndpointInfo::from(self.app.info()))
- }
-
- fn to_handler(&self, path: EndpointPath) -> Box> {
- Box::new(PageHandler {
- app: self.app.clone(),
- prefix: self.prefix.clone(),
- path: path,
- file: None,
- write_pos: 0,
- safe_to_embed: self.safe_to_embed,
- })
- }
-}
-
-impl From for EndpointInfo {
- fn from(info: Info) -> Self {
- EndpointInfo {
- name: info.name,
- description: info.description,
- author: info.author,
- icon_url: info.icon_url,
- version: info.version,
- }
- }
-}
-
-struct PageHandler {
- app: Arc,
- prefix: Option,
- path: EndpointPath,
- file: Option,
- write_pos: usize,
- safe_to_embed: bool,
-}
-
-impl PageHandler {
- fn extract_path(&self, path: &str) -> String {
- let app_id = &self.path.app_id;
- let prefix = "/".to_owned() + self.prefix.as_ref().unwrap_or(app_id);
- let prefix_with_slash = prefix.clone() + "/";
- let query_pos = path.find('?').unwrap_or_else(|| path.len());
-
- // Index file support
- match path == "/" || path == &prefix || path == &prefix_with_slash {
- true => "index.html".to_owned(),
- false => if path.starts_with(&prefix_with_slash) {
- path[prefix_with_slash.len()..query_pos].to_owned()
- } else if path.starts_with("/") {
- path[1..query_pos].to_owned()
- } else {
- path[0..query_pos].to_owned()
- }
- }
- }
-}
-
-impl server::Handler for PageHandler {
- fn on_request(&mut self, req: server::Request) -> Next {
- self.file = match *req.uri() {
- RequestUri::AbsolutePath(ref path) => {
- Some(self.extract_path(path))
- },
- RequestUri::AbsoluteUri(ref url) => {
- Some(self.extract_path(url.path()))
- },
- _ => None,
- };
- Next::write()
- }
-
- fn on_request_readable(&mut self, _decoder: &mut Decoder) -> Next {
- Next::write()
- }
-
- fn on_response(&mut self, res: &mut server::Response) -> Next {
- if let Some(f) = self.file.as_ref().and_then(|f| self.app.file(f)) {
- res.set_status(StatusCode::Ok);
- res.headers_mut().set(header::ContentType(f.content_type.parse().unwrap()));
- if !self.safe_to_embed {
- res.headers_mut().set_raw("X-Frame-Options", vec![b"SAMEORIGIN".to_vec()]);
- }
- Next::write()
- } else {
- res.set_status(StatusCode::NotFound);
- Next::write()
- }
- }
-
- fn on_response_writable(&mut self, encoder: &mut Encoder) -> Next {
- let (wrote, res) = {
- let file = self.file.as_ref().and_then(|f| self.app.file(f));
- match file {
- None => (None, Next::end()),
- Some(f) if self.write_pos == f.content.len() => (None, Next::end()),
- Some(f) => match encoder.write(&f.content[self.write_pos..]) {
- Ok(bytes) => (Some(bytes), Next::write()),
- Err(e) => match e.kind() {
- ::std::io::ErrorKind::WouldBlock => (None, Next::write()),
- _ => (None, Next::end())
- },
- }
- }
- };
- if let Some(bytes) = wrote {
- self.write_pos += bytes;
- }
- res
- }
-}
-
-
-#[cfg(test)]
-use parity_dapps::File;
-
-#[cfg(test)]
-#[derive(Default)]
-struct TestWebapp;
-
-#[cfg(test)]
-impl WebApp for TestWebapp {
- fn file(&self, _path: &str) -> Option<&File> {
- None
- }
- fn info(&self) -> Info {
- unimplemented!()
- }
-}
-
-#[test]
-fn should_extract_path_with_appid() {
- // given
- let path1 = "/";
- let path2= "/test.css";
- let path3 = "/app/myfile.txt";
- let path4 = "/app/myfile.txt?query=123";
- let page_handler = PageHandler {
- app: Arc::new(TestWebapp),
- prefix: None,
- path: EndpointPath {
- app_id: "app".to_owned(),
- host: "".to_owned(),
- port: 8080
- },
- file: None,
- write_pos: 0,
- safe_to_embed: true,
- };
-
- // when
- let res1 = page_handler.extract_path(path1);
- let res2 = page_handler.extract_path(path2);
- let res3 = page_handler.extract_path(path3);
- let res4 = page_handler.extract_path(path4);
-
- // then
- assert_eq!(&res1, "index.html");
- assert_eq!(&res2, "test.css");
- assert_eq!(&res3, "myfile.txt");
- assert_eq!(&res4, "myfile.txt");
-}
diff --git a/ethcore/src/evm/evm.rs b/ethcore/src/evm/evm.rs
index b6c2debc5..740774f38 100644
--- a/ethcore/src/evm/evm.rs
+++ b/ethcore/src/evm/evm.rs
@@ -63,13 +63,43 @@ pub enum Error {
Internal,
}
-/// Evm result.
-///
-/// Returns `gas_left` if execution is successful, otherwise error.
-pub type Result = result::Result;
+/// A specialized version of Result over EVM errors.
+pub type Result = ::std::result::Result;
-/// Evm interface.
+/// Gas Left: either it is a known value, or it needs to be computed by processing
+/// a return instruction.
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum GasLeft<'a> {
+ /// Known gas left
+ Known(U256),
+ /// Return instruction must be processed.
+ NeedsReturn(U256, &'a [u8]),
+}
+
+/// Types that can be "finalized" using an EVM.
+///
+/// In practice, this is just used to define an inherent impl on
+/// `Reult>`.
+pub trait Finalize {
+ /// Consume the externalities, call return if necessary, and produce a final amount of gas left.
+ fn finalize(self, ext: E) -> Result;
+}
+
+impl<'a> Finalize for Result> {
+ fn finalize(self, ext: E) -> Result {
+ match self {
+ Ok(GasLeft::Known(gas)) => Ok(gas),
+ Ok(GasLeft::NeedsReturn(gas, ret_code)) => ext.ret(&gas, ret_code),
+ Err(err) => Err(err),
+ }
+ }
+}
+
+/// Evm interface
pub trait Evm {
/// This function should be used to execute transaction.
- fn exec(&self, params: ActionParams, ext: &mut Ext) -> Result;
+ ///
+ /// It returns either an error, a known amount of gas left, or parameters to be used
+ /// to compute the final gas left.
+ fn exec(&mut self, params: ActionParams, ext: &mut Ext) -> Result;
}
diff --git a/ethcore/src/evm/ext.rs b/ethcore/src/evm/ext.rs
index 1c21e467a..0aaa4dac6 100644
--- a/ethcore/src/evm/ext.rs
+++ b/ethcore/src/evm/ext.rs
@@ -17,7 +17,7 @@
//! Interface for Evm externalities.
use util::common::*;
-use evm::{Schedule, Error};
+use evm::{self, Schedule};
use env_info::*;
/// Result of externalities create function.
@@ -85,7 +85,7 @@ pub trait Ext {
/// Should be called when transaction calls `RETURN` opcode.
/// Returns gas_left if cost of returning the data is not too high.
- fn ret(&mut self, gas: &U256, data: &[u8]) -> Result;
+ fn ret(self, gas: &U256, data: &[u8]) -> evm::Result where Self: Sized;
/// Should be called when contract commits suicide.
/// Address to which funds should be refunded.
diff --git a/ethcore/src/evm/factory.rs b/ethcore/src/evm/factory.rs
index 3e60e8808..f55e064c7 100644
--- a/ethcore/src/evm/factory.rs
+++ b/ethcore/src/evm/factory.rs
@@ -89,10 +89,10 @@ impl Factory {
pub fn create(&self) -> Box {
match self.evm {
VMType::Jit => {
- Box::new(super::jit::JitEvm)
+ Box::new(super::jit::JitEvm::default())
},
VMType::Interpreter => {
- Box::new(super::interpreter::Interpreter)
+ Box::new(super::interpreter::Interpreter::default())
}
}
}
@@ -102,7 +102,7 @@ impl Factory {
pub fn create(&self) -> Box {
match self.evm {
VMType::Interpreter => {
- Box::new(super::interpreter::Interpreter)
+ Box::new(super::interpreter::Interpreter::default())
}
}
}
diff --git a/ethcore/src/evm/interpreter.rs b/ethcore/src/evm/interpreter.rs
index 9cf4d6034..1514b3e2e 100644
--- a/ethcore/src/evm/interpreter.rs
+++ b/ethcore/src/evm/interpreter.rs
@@ -21,7 +21,7 @@ use trace::VMTracer;
use super::instructions as instructions;
use super::instructions::{Instruction, get_info};
use std::marker::Copy;
-use evm::{self, MessageCallResult, ContractCreateResult};
+use evm::{self, MessageCallResult, ContractCreateResult, GasLeft};
#[cfg(not(feature = "evm-debug"))]
macro_rules! evm_debug {
@@ -279,21 +279,26 @@ enum InstructionResult {
GasLeft(U256),
UnusedGas(U256),
JumpToPosition(U256),
- StopExecutionWithGasLeft(U256),
- StopExecution
+ // gas left, init_orf, init_size
+ StopExecutionNeedsReturn(U256, U256, U256),
+ StopExecution,
}
/// Intepreter EVM implementation
-pub struct Interpreter;
+#[derive(Default)]
+pub struct Interpreter {
+ mem: Vec,
+}
impl evm::Evm for Interpreter {
- fn exec(&self, params: ActionParams, ext: &mut evm::Ext) -> evm::Result {
+ fn exec(&mut self, params: ActionParams, ext: &mut evm::Ext) -> evm::Result {
+ self.mem.clear();
+
let code = ¶ms.code.as_ref().unwrap();
let valid_jump_destinations = self.find_jump_destinations(&code);
let mut current_gas = params.gas;
let mut stack = VecStack::with_capacity(ext.schedule().stack_limit, U256::zero());
- let mut mem = vec![];
let mut reader = CodeReader {
position: 0,
code: &code
@@ -303,7 +308,7 @@ impl evm::Evm for Interpreter {
let instruction = code[reader.position];
// Calculate gas cost
- let (gas_cost, mem_size) = try!(self.get_gas_cost_mem(ext, instruction, &mut mem, &stack));
+ let (gas_cost, mem_size) = try!(self.get_gas_cost_mem(ext, instruction, &stack));
// TODO: make compile-time removable if too much of a performance hit.
let trace_executed = ext.trace_prepare_execute(reader.position, instruction, &gas_cost);
@@ -311,7 +316,7 @@ impl evm::Evm for Interpreter {
reader.position += 1;
try!(self.verify_gas(¤t_gas, &gas_cost));
- mem.expand(mem_size);
+ self.mem.expand(mem_size);
current_gas = current_gas - gas_cost; //TODO: use operator -=
evm_debug!({
@@ -331,11 +336,11 @@ impl evm::Evm for Interpreter {
// Execute instruction
let result = try!(self.exec_instruction(
- current_gas, ¶ms, ext, instruction, &mut reader, &mut mem, &mut stack
+ current_gas, ¶ms, ext, instruction, &mut reader, &mut stack
));
if trace_executed {
- ext.trace_executed(current_gas, stack.peek_top(get_info(instruction).ret), mem_written.map(|(o, s)| (o, &(mem[o..(o + s)]))), store_written);
+ ext.trace_executed(current_gas, stack.peek_top(get_info(instruction).ret), mem_written.map(|(o, s)| (o, &(self.mem[o..(o + s)]))), store_written);
}
// Advance
@@ -354,29 +359,25 @@ impl evm::Evm for Interpreter {
let pos = try!(self.verify_jump(position, &valid_jump_destinations));
reader.position = pos;
},
- InstructionResult::StopExecutionWithGasLeft(gas_left) => {
- current_gas = gas_left;
- reader.position = code.len();
+ InstructionResult::StopExecutionNeedsReturn(gas, off, size) => {
+ return Ok(GasLeft::NeedsReturn(gas, self.mem.read_slice(off, size)));
},
- InstructionResult::StopExecution => {
- reader.position = code.len();
- }
+ InstructionResult::StopExecution => break,
}
}
- Ok(current_gas)
+ Ok(GasLeft::Known(current_gas))
}
}
impl Interpreter {
#[cfg_attr(feature="dev", allow(cyclomatic_complexity))]
fn get_gas_cost_mem(
- &self,
+ &mut self,
ext: &evm::Ext,
instruction: Instruction,
- mem: &mut Memory,
stack: &Stack
- ) -> Result<(U256, usize), evm::Error> {
+ ) -> evm::Result<(U256, usize)> {
let schedule = ext.schedule();
let info = instructions::get_info(instruction);
@@ -492,12 +493,12 @@ impl Interpreter {
Ok((gas, 0))
},
InstructionCost::GasMem(gas, mem_size) => {
- let (mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, mem.size(), &mem_size));
+ let (mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, self.mem.size(), &mem_size));
let gas = overflowing!(gas.overflowing_add(mem_gas));
Ok((gas, new_mem_size))
},
InstructionCost::GasMemCopy(gas, mem_size, copy) => {
- let (mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, mem.size(), &mem_size));
+ let (mem_gas, new_mem_size) = try!(self.mem_gas_cost(schedule, self.mem.size(), &mem_size));
let copy = overflowing!(add_u256_usize(©, 31));
let copy_gas = U256::from(schedule.copy_gas) * (copy / U256::from(32));
let gas = overflowing!(gas.overflowing_add(copy_gas));
@@ -532,7 +533,7 @@ impl Interpreter {
}
}
- fn mem_gas_cost(&self, schedule: &evm::Schedule, current_mem_size: usize, mem_size: &U256) -> Result<(U256, usize), evm::Error> {
+ fn mem_gas_cost(&self, schedule: &evm::Schedule, current_mem_size: usize, mem_size: &U256) -> evm::Result<(U256, usize)> {
let gas_for_mem = |mem_size: U256| {
let s = mem_size >> 5;
// s * memory_gas + s * s / quad_coeff_div
@@ -557,11 +558,11 @@ impl Interpreter {
}, req_mem_size_rounded.low_u64() as usize))
}
- fn mem_needed_const(&self, mem: &U256, add: usize) -> Result {
+ fn mem_needed_const(&self, mem: &U256, add: usize) -> evm::Result {
Ok(overflowing!(mem.overflowing_add(U256::from(add))))
}
- fn mem_needed(&self, offset: &U256, size: &U256) -> Result {
+ fn mem_needed(&self, offset: &U256, size: &U256) -> evm::Result {
if self.is_zero(size) {
return Ok(U256::zero());
}
@@ -571,15 +572,14 @@ impl Interpreter {
#[cfg_attr(feature="dev", allow(too_many_arguments))]
fn exec_instruction(
- &self,
+ &mut self,
gas: Gas,
params: &ActionParams,
ext: &mut evm::Ext,
instruction: Instruction,
code: &mut CodeReader,
- mem: &mut Memory,
stack: &mut Stack
- ) -> Result {
+ ) -> evm::Result {
match instruction {
instructions::JUMP => {
let jump = stack.pop_back();
@@ -604,7 +604,7 @@ impl Interpreter {
let init_off = stack.pop_back();
let init_size = stack.pop_back();
- let contract_code = mem.read_slice(init_off, init_size);
+ let contract_code = self.mem.read_slice(init_off, init_size);
let can_create = ext.balance(¶ms.address) >= endowment && ext.depth() < ext.schedule().max_depth;
if !can_create {
@@ -671,8 +671,8 @@ impl Interpreter {
let call_result = {
// we need to write and read from memory in the same time
// and we don't want to copy
- let input = unsafe { ::std::mem::transmute(mem.read_slice(in_off, in_size)) };
- let output = mem.writeable_slice(out_off, out_size);
+ let input = unsafe { ::std::mem::transmute(self.mem.read_slice(in_off, in_size)) };
+ let output = self.mem.writeable_slice(out_off, out_size);
ext.call(&call_gas, sender_address, receive_address, value, input, &code_address, output)
};
@@ -690,11 +690,8 @@ impl Interpreter {
instructions::RETURN => {
let init_off = stack.pop_back();
let init_size = stack.pop_back();
- let return_code = mem.read_slice(init_off, init_size);
- let gas_left = try!(ext.ret(&gas, &return_code));
- return Ok(InstructionResult::StopExecutionWithGasLeft(
- gas_left
- ));
+
+ return Ok(InstructionResult::StopExecutionNeedsReturn(gas, init_off, init_size))
},
instructions::STOP => {
return Ok(InstructionResult::StopExecution);
@@ -713,7 +710,7 @@ impl Interpreter {
.iter()
.map(H256::from)
.collect();
- ext.log(topics, mem.read_slice(offset, size));
+ ext.log(topics, self.mem.read_slice(offset, size));
},
instructions::PUSH1...instructions::PUSH32 => {
let bytes = instructions::get_push_bytes(instruction);
@@ -721,26 +718,26 @@ impl Interpreter {
stack.push(val);
},
instructions::MLOAD => {
- let word = mem.read(stack.pop_back());
+ let word = self.mem.read(stack.pop_back());
stack.push(U256::from(word));
},
instructions::MSTORE => {
let offset = stack.pop_back();
let word = stack.pop_back();
- mem.write(offset, word);
+ Memory::write(&mut self.mem, offset, word);
},
instructions::MSTORE8 => {
let offset = stack.pop_back();
let byte = stack.pop_back();
- mem.write_byte(offset, byte);
+ self.mem.write_byte(offset, byte);
},
instructions::MSIZE => {
- stack.push(U256::from(mem.size()));
+ stack.push(U256::from(self.mem.size()));
},
instructions::SHA3 => {
let offset = stack.pop_back();
let size = stack.pop_back();
- let sha3 = mem.read_slice(offset, size).sha3();
+ let sha3 = self.mem.read_slice(offset, size).sha3();
stack.push(U256::from(sha3.as_slice()));
},
instructions::SLOAD => {
@@ -813,15 +810,15 @@ impl Interpreter {
stack.push(U256::from(len));
},
instructions::CALLDATACOPY => {
- self.copy_data_to_memory(mem, stack, ¶ms.data.clone().unwrap_or_else(|| vec![]));
+ self.copy_data_to_memory(stack, ¶ms.data.clone().unwrap_or_else(|| vec![]));
},
instructions::CODECOPY => {
- self.copy_data_to_memory(mem, stack, ¶ms.code.clone().unwrap_or_else(|| vec![]));
+ self.copy_data_to_memory(stack, ¶ms.code.clone().unwrap_or_else(|| vec![]));
},
instructions::EXTCODECOPY => {
let address = u256_to_address(&stack.pop_back());
let code = ext.extcode(&address);
- self.copy_data_to_memory(mem, stack, &code);
+ self.copy_data_to_memory(stack, &code);
},
instructions::GASPRICE => {
stack.push(params.gas_price.clone());
@@ -853,7 +850,7 @@ impl Interpreter {
Ok(InstructionResult::Ok)
}
- fn copy_data_to_memory(&self, mem: &mut Memory, stack: &mut Stack, data: &[u8]) {
+ fn copy_data_to_memory(&mut self, stack: &mut Stack, data: &[u8]) {
let dest_offset = stack.pop_back();
let source_offset = stack.pop_back();
let size = stack.pop_back();
@@ -862,9 +859,9 @@ impl Interpreter {
let output_end = match source_offset > source_size || size > source_size || source_offset + size > source_size {
true => {
let zero_slice = if source_offset > source_size {
- mem.writeable_slice(dest_offset, size)
+ self.mem.writeable_slice(dest_offset, size)
} else {
- mem.writeable_slice(dest_offset + source_size - source_offset, source_offset + size - source_size)
+ self.mem.writeable_slice(dest_offset + source_size - source_offset, source_offset + size - source_size)
};
for i in zero_slice.iter_mut() {
*i = 0;
@@ -876,7 +873,7 @@ impl Interpreter {
if source_offset < source_size {
let output_begin = source_offset.low_u64() as usize;
- mem.write_slice(dest_offset, &data[output_begin..output_end]);
+ self.mem.write_slice(dest_offset, &data[output_begin..output_end]);
}
}
@@ -885,7 +882,7 @@ impl Interpreter {
info: &instructions::InstructionInfo,
stack_limit: usize,
stack: &Stack
- ) -> Result<(), evm::Error> {
+ ) -> evm::Result<()> {
if !stack.has(info.args) {
Err(evm::Error::StackUnderflow {
instruction: info.name,
@@ -903,14 +900,14 @@ impl Interpreter {
}
}
- fn verify_gas(&self, current_gas: &U256, gas_cost: &U256) -> Result<(), evm::Error> {
+ fn verify_gas(&self, current_gas: &U256, gas_cost: &U256) -> evm::Result<()> {
match current_gas < gas_cost {
true => Err(evm::Error::OutOfGas),
false => Ok(())
}
}
- fn verify_jump(&self, jump_u: U256, valid_jump_destinations: &HashSet) -> Result {
+ fn verify_jump(&self, jump_u: U256, valid_jump_destinations: &HashSet) -> evm::Result {
let jump = jump_u.low_u64() as usize;
if valid_jump_destinations.contains(&jump) && jump_u < U256::from(!0 as usize) {
@@ -934,7 +931,7 @@ impl Interpreter {
}
}
- fn exec_stack_instruction(&self, instruction: Instruction, stack: &mut Stack) -> Result<(), evm::Error> {
+ fn exec_stack_instruction(&self, instruction: Instruction, stack: &mut Stack) -> evm::Result<()> {
match instruction {
instructions::DUP1...instructions::DUP16 => {
let position = instructions::get_dup_position(instruction);
@@ -1185,7 +1182,7 @@ fn address_to_u256(value: Address) -> U256 {
#[test]
fn test_mem_gas_cost() {
// given
- let interpreter = Interpreter;
+ let interpreter = Interpreter::default();
let schedule = evm::Schedule::default();
let current_mem_size = 5;
let mem_size = !U256::zero();
@@ -1208,7 +1205,7 @@ mod tests {
#[test]
fn test_find_jump_destinations() {
// given
- let interpreter = Interpreter;
+ let interpreter = Interpreter::default();
let code = "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff5b01600055".from_hex().unwrap();
// when
@@ -1221,7 +1218,7 @@ mod tests {
#[test]
fn test_calculate_mem_cost() {
// given
- let interpreter = Interpreter;
+ let interpreter = Interpreter::default();
let schedule = evm::Schedule::default();
let current_mem_size = 0;
let mem_size = U256::from(5);
diff --git a/ethcore/src/evm/jit.rs b/ethcore/src/evm/jit.rs
index 694c1668a..d46ad917f 100644
--- a/ethcore/src/evm/jit.rs
+++ b/ethcore/src/evm/jit.rs
@@ -18,7 +18,7 @@
use common::*;
use trace::VMTracer;
use evmjit;
-use evm;
+use evm::{self, Error, GasLeft};
/// Should be used to convert jit types to ethcore
trait FromJit: Sized {
@@ -107,8 +107,8 @@ impl IntoJit for Address {
}
/// Externalities adapter. Maps callbacks from evmjit to externalities trait.
-///
-/// Evmjit doesn't have to know about children execution failures.
+///
+/// Evmjit doesn't have to know about children execution failures.
/// This adapter 'catches' them and moves upstream.
struct ExtAdapter<'a> {
ext: &'a mut evm::Ext,
@@ -166,7 +166,7 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
init_beg: *const u8,
init_size: u64,
address: *mut evmjit::H256) {
-
+
let gas = unsafe { U256::from(*io_gas) };
let value = unsafe { U256::from_jit(&*value) };
let code = unsafe { slice::from_raw_parts(init_beg, init_size as usize) };
@@ -241,9 +241,9 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
}
match self.ext.call(
- &call_gas,
+ &call_gas,
&sender_address,
- &receive_address,
+ &receive_address,
value,
unsafe { slice::from_raw_parts(in_beg, in_size as usize) },
&code_address,
@@ -284,7 +284,7 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
if !topic4.is_null() {
topics.push(H256::from_jit(&*topic4));
}
-
+
let bytes_ref: &[u8] = slice::from_raw_parts(beg, size as usize);
self.ext.log(topics, bytes_ref);
}
@@ -301,10 +301,13 @@ impl<'a> evmjit::Ext for ExtAdapter<'a> {
}
}
-pub struct JitEvm;
+#[derive(Default)]
+pub struct JitEvm {
+ ctxt: Option,
+}
impl evm::Evm for JitEvm {
- fn exec(&self, params: ActionParams, ext: &mut evm::Ext) -> evm::Result {
+ fn exec(&mut self, params: ActionParams, ext: &mut evm::Ext) -> evm::Result {
// Dirty hack. This is unsafe, but we interact with ffi, so it's justified.
let ext_adapter: ExtAdapter<'static> = unsafe { ::std::mem::transmute(ExtAdapter::new(ext, params.address.clone())) };
let mut ext_handle = evmjit::ExtHandle::new(ext_adapter);
@@ -343,15 +346,17 @@ impl evm::Evm for JitEvm {
// don't really know why jit timestamp is int..
data.timestamp = ext.env_info().timestamp as i64;
- let mut context = unsafe { evmjit::ContextHandle::new(data, schedule, &mut ext_handle) };
+ self.context = Some(unsafe { evmjit::ContextHandle::new(data, schedule, &mut ext_handle) });
+ let context = self.context.as_ref_mut().unwrap();
let res = context.exec();
-
+
match res {
- evmjit::ReturnCode::Stop => Ok(U256::from(context.gas_left())),
- evmjit::ReturnCode::Return => ext.ret(&U256::from(context.gas_left()), context.output_data()),
- evmjit::ReturnCode::Suicide => {
+ evmjit::ReturnCode::Stop => Ok(GasLeft::Known(U256::from(context.gas_left()))),
+ evmjit::ReturnCode::Return =>
+ Ok(GasLeft::NeedsReturn(U256::from(context.gas_left()), context.output_data())),
+ evmjit::ReturnCode::Suicide => {
ext.suicide(&Address::from_jit(&context.suicide_refund_address()));
- Ok(U256::from(context.gas_left()))
+ Ok(GasLeft::Known(U256::from(context.gas_left())))
},
evmjit::ReturnCode::OutOfGas => Err(evm::Error::OutOfGas),
_err => Err(evm::Error::Internal)
@@ -372,7 +377,7 @@ fn test_to_and_from_h256() {
let h = H256::from_str("d4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3").unwrap();
let j: ::evmjit::I256 = h.clone().into_jit();
let h2 = H256::from_jit(&j);
-
+
assert_eq!(h, h2);
let j: ::evmjit::H256 = h.clone().into_jit();
diff --git a/ethcore/src/evm/mod.rs b/ethcore/src/evm/mod.rs
index 06ce5e7e8..5e7b67cfb 100644
--- a/ethcore/src/evm/mod.rs
+++ b/ethcore/src/evm/mod.rs
@@ -29,7 +29,7 @@ mod jit;
#[cfg(test)]
mod tests;
-pub use self::evm::{Evm, Error, Result};
+pub use self::evm::{Evm, Error, Finalize, GasLeft, Result};
pub use self::ext::{Ext, ContractCreateResult, MessageCallResult};
pub use self::factory::{Factory, VMType};
pub use self::schedule::Schedule;
diff --git a/ethcore/src/evm/tests.rs b/ethcore/src/evm/tests.rs
index 445c0be41..ba156e6dd 100644
--- a/ethcore/src/evm/tests.rs
+++ b/ethcore/src/evm/tests.rs
@@ -15,8 +15,7 @@
// along with Parity. If not, see .
use common::*;
-use evm;
-use evm::{Ext, Schedule, Factory, VMType, ContractCreateResult, MessageCallResult};
+use evm::{self, Ext, Schedule, Factory, GasLeft, VMType, ContractCreateResult, MessageCallResult};
use std::fmt::Debug;
struct FakeLogEntry {
@@ -58,6 +57,15 @@ struct FakeExt {
calls: HashSet,
}
+// similar to the normal `finalize` function, but ignoring NeedsReturn.
+fn test_finalize(res: Result) -> Result {
+ match res {
+ Ok(GasLeft::Known(gas)) => Ok(gas),
+ Ok(GasLeft::NeedsReturn(_, _)) => unimplemented!(), // since ret is unimplemented.
+ Err(e) => Err(e),
+ }
+}
+
impl FakeExt {
fn new() -> Self {
FakeExt::default()
@@ -136,7 +144,7 @@ impl Ext for FakeExt {
});
}
- fn ret(&mut self, _gas: &U256, _data: &[u8]) -> result::Result {
+ fn ret(self, _gas: &U256, _data: &[u8]) -> evm::Result {
unimplemented!();
}
@@ -173,8 +181,8 @@ fn test_stack_underflow() {
let mut ext = FakeExt::new();
let err = {
- let vm : Box = Box::new(super::interpreter::Interpreter);
- vm.exec(params, &mut ext).unwrap_err()
+ let mut vm : Box = Box::new(super::interpreter::Interpreter::default());
+ test_finalize(vm.exec(params, &mut ext)).unwrap_err()
};
match err {
@@ -200,8 +208,8 @@ fn test_add(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_988));
@@ -220,8 +228,8 @@ fn test_sha3(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_961));
@@ -240,8 +248,8 @@ fn test_address(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_995));
@@ -262,8 +270,8 @@ fn test_origin(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_995));
@@ -284,8 +292,8 @@ fn test_sender(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_995));
@@ -319,8 +327,8 @@ fn test_extcodecopy(factory: super::Factory) {
ext.codes.insert(sender, sender_code);
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_935));
@@ -339,8 +347,8 @@ fn test_log_empty(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(99_619));
@@ -371,8 +379,8 @@ fn test_log_sender(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(98_974));
@@ -396,8 +404,8 @@ fn test_blockhash(factory: super::Factory) {
ext.blockhashes.insert(U256::zero(), blockhash.clone());
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_974));
@@ -418,8 +426,8 @@ fn test_calldataload(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_991));
@@ -439,8 +447,8 @@ fn test_author(factory: super::Factory) {
ext.info.author = author;
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_995));
@@ -459,8 +467,8 @@ fn test_timestamp(factory: super::Factory) {
ext.info.timestamp = timestamp;
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_995));
@@ -479,8 +487,8 @@ fn test_number(factory: super::Factory) {
ext.info.number = number;
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_995));
@@ -499,8 +507,8 @@ fn test_difficulty(factory: super::Factory) {
ext.info.difficulty = difficulty;
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_995));
@@ -519,8 +527,8 @@ fn test_gas_limit(factory: super::Factory) {
ext.info.gas_limit = gas_limit;
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(gas_left, U256::from(79_995));
@@ -537,8 +545,8 @@ fn test_mul(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "000000000000000000000000000000000000000000000000734349397b853383");
@@ -555,8 +563,8 @@ fn test_sub(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000012364ad0302");
@@ -573,8 +581,8 @@ fn test_div(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "000000000000000000000000000000000000000000000000000000000002e0ac");
@@ -591,8 +599,8 @@ fn test_div_zero(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000000");
@@ -609,8 +617,8 @@ fn test_mod(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000076b4b");
@@ -628,8 +636,8 @@ fn test_smod(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000076b4b");
@@ -647,8 +655,8 @@ fn test_sdiv(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "000000000000000000000000000000000000000000000000000000000002e0ac");
@@ -666,8 +674,8 @@ fn test_exp(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "90fd23767b60204c3d6fc8aec9e70a42a3f127140879c133a20129a597ed0c59");
@@ -686,8 +694,8 @@ fn test_comparison(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000000");
@@ -707,8 +715,8 @@ fn test_signed_comparison(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000000");
@@ -728,8 +736,8 @@ fn test_bitops(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "00000000000000000000000000000000000000000000000000000000000000f0");
@@ -751,8 +759,8 @@ fn test_addmod_mulmod(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000001");
@@ -772,8 +780,8 @@ fn test_byte(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000000");
@@ -791,8 +799,8 @@ fn test_signextend(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000fff");
@@ -811,8 +819,8 @@ fn test_badinstruction_int() {
let mut ext = FakeExt::new();
let err = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap_err()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap_err()
};
match err {
@@ -831,8 +839,8 @@ fn test_pop(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "00000000000000000000000000000000000000000000000000000000000000f0");
@@ -851,8 +859,8 @@ fn test_extops(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_store(&ext, 0, "0000000000000000000000000000000000000000000000000000000000000004"); // PC / CALLDATASIZE
@@ -874,8 +882,8 @@ fn test_jumps(factory: super::Factory) {
let mut ext = FakeExt::new();
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_eq!(ext.sstore_clears, 1);
@@ -903,8 +911,8 @@ fn test_calls(factory: super::Factory) {
};
let gas_left = {
- let vm = factory.create();
- vm.exec(params, &mut ext).unwrap()
+ let mut vm = factory.create();
+ test_finalize(vm.exec(params, &mut ext)).unwrap()
};
assert_set_contains(&ext.calls, &FakeCall {
diff --git a/ethcore/src/executive.rs b/ethcore/src/executive.rs
index 36f66d6db..fdc1c7d18 100644
--- a/ethcore/src/executive.rs
+++ b/ethcore/src/executive.rs
@@ -18,7 +18,7 @@
use common::*;
use state::*;
use engine::*;
-use evm::{self, Ext, Factory};
+use evm::{self, Ext, Factory, Finalize};
use externalities::*;
use substate::*;
use trace::{Trace, Tracer, NoopTracer, ExecutiveTracer, VMTrace, VMTracer, ExecutiveVMTracer, NoopVMTracer};
@@ -205,13 +205,13 @@ impl<'a> Executive<'a> {
output_policy: OutputPolicy,
tracer: &mut T,
vm_tracer: &mut V
- ) -> evm::Result where T: Tracer, V: VMTracer {
+ ) -> evm::Result where T: Tracer, V: VMTracer {
// Ordinary execution - keep VM in same thread
if (self.depth + 1) % MAX_VM_DEPTH_FOR_THREAD != 0 {
let vm_factory = self.vm_factory;
let mut ext = self.as_externalities(OriginInfo::from(¶ms), unconfirmed_substate, output_policy, tracer, vm_tracer);
trace!(target: "executive", "ext.schedule.have_delegate_call: {}", ext.schedule().have_delegate_call);
- return vm_factory.create().exec(params, &mut ext);
+ return vm_factory.create().exec(params, &mut ext).finalize(ext);
}
// Start in new thread to reset stack
@@ -222,7 +222,7 @@ impl<'a> Executive<'a> {
let mut ext = self.as_externalities(OriginInfo::from(¶ms), unconfirmed_substate, output_policy, tracer, vm_tracer);
scope.spawn(move || {
- vm_factory.create().exec(params, &mut ext)
+ vm_factory.create().exec(params, &mut ext).finalize(ext)
})
}).join()
}
@@ -238,7 +238,7 @@ impl<'a> Executive<'a> {
mut output: BytesRef,
tracer: &mut T,
vm_tracer: &mut V
- ) -> evm::Result where T: Tracer, V: VMTracer {
+ ) -> evm::Result where T: Tracer, V: VMTracer {
// backup used in case of running out of gas
self.state.snapshot();
@@ -351,7 +351,7 @@ impl<'a> Executive<'a> {
substate: &mut Substate,
tracer: &mut T,
vm_tracer: &mut V
- ) -> evm::Result where T: Tracer, V: VMTracer {
+ ) -> evm::Result where T: Tracer, V: VMTracer {
// backup used in case of running out of gas
self.state.snapshot();
@@ -402,7 +402,7 @@ impl<'a> Executive<'a> {
&mut self,
t: &SignedTransaction,
substate: Substate,
- result: evm::Result,
+ result: evm::Result,
output: Bytes,
trace: Option,
vm_trace: Option
@@ -470,7 +470,7 @@ impl<'a> Executive<'a> {
}
}
- fn enact_result(&mut self, result: &evm::Result, substate: &mut Substate, un_substate: Substate) {
+ fn enact_result(&mut self, result: &evm::Result, substate: &mut Substate, un_substate: Substate) {
match *result {
Err(evm::Error::OutOfGas)
| Err(evm::Error::BadJumpDestination {..})
@@ -683,14 +683,14 @@ mod tests {
parent_step: 0,
code: vec![124, 96, 16, 128, 96, 12, 96, 0, 57, 96, 0, 243, 0, 96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53, 85, 96, 0, 82, 96, 29, 96, 3, 96, 23, 240, 96, 0, 85],
operations: vec![
- VMOperation { pc: 0, instruction: 124, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99997.into(), stack_push: vec_into![U256::from_dec_str("2589892687202724018173567190521546555304938078595079151649957320078677").unwrap()], mem_diff: None, store_diff: None }) },
- VMOperation { pc: 30, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99994.into(), stack_push: vec_into![0], mem_diff: None, store_diff: None }) },
- VMOperation { pc: 32, instruction: 82, gas_cost: 6.into(), executed: Some(VMExecutedOperation { gas_used: 99988.into(), stack_push: vec_into![], mem_diff: Some(MemoryDiff { offset: 0, data: vec![0, 0, 0, 96, 16, 128, 96, 12, 96, 0, 57, 96, 0, 243, 0, 96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53, 85] }), store_diff: None }) },
- VMOperation { pc: 33, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99985.into(), stack_push: vec_into![29], mem_diff: None, store_diff: None }) },
- VMOperation { pc: 35, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99982.into(), stack_push: vec_into![3], mem_diff: None, store_diff: None }) },
- VMOperation { pc: 37, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99979.into(), stack_push: vec_into![23], mem_diff: None, store_diff: None }) },
- VMOperation { pc: 39, instruction: 240, gas_cost: 32000.into(), executed: Some(VMExecutedOperation { gas_used: 67979.into(), stack_push: vec_into![U256::from_dec_str("1135198453258042933984631383966629874710669425204").unwrap()], mem_diff: None, store_diff: None }) },
- VMOperation { pc: 40, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 64752.into(), stack_push: vec_into![0], mem_diff: None, store_diff: None }) },
+ VMOperation { pc: 0, instruction: 124, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99997.into(), stack_push: vec_into![U256::from_dec_str("2589892687202724018173567190521546555304938078595079151649957320078677").unwrap()], mem_diff: None, store_diff: None }) },
+ VMOperation { pc: 30, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99994.into(), stack_push: vec_into![0], mem_diff: None, store_diff: None }) },
+ VMOperation { pc: 32, instruction: 82, gas_cost: 6.into(), executed: Some(VMExecutedOperation { gas_used: 99988.into(), stack_push: vec_into![], mem_diff: Some(MemoryDiff { offset: 0, data: vec![0, 0, 0, 96, 16, 128, 96, 12, 96, 0, 57, 96, 0, 243, 0, 96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53, 85] }), store_diff: None }) },
+ VMOperation { pc: 33, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99985.into(), stack_push: vec_into![29], mem_diff: None, store_diff: None }) },
+ VMOperation { pc: 35, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99982.into(), stack_push: vec_into![3], mem_diff: None, store_diff: None }) },
+ VMOperation { pc: 37, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 99979.into(), stack_push: vec_into![23], mem_diff: None, store_diff: None }) },
+ VMOperation { pc: 39, instruction: 240, gas_cost: 32000.into(), executed: Some(VMExecutedOperation { gas_used: 67979.into(), stack_push: vec_into![U256::from_dec_str("1135198453258042933984631383966629874710669425204").unwrap()], mem_diff: None, store_diff: None }) },
+ VMOperation { pc: 40, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 64752.into(), stack_push: vec_into![0], mem_diff: None, store_diff: None }) },
VMOperation { pc: 42, instruction: 85, gas_cost: 20000.into(), executed: Some(VMExecutedOperation { gas_used: 44752.into(), stack_push: vec_into![], mem_diff: None, store_diff: Some(StorageDiff { location: 0.into(), value: U256::from_dec_str("1135198453258042933984631383966629874710669425204").unwrap() }) }) }
],
subs: vec![
@@ -698,12 +698,12 @@ mod tests {
parent_step: 7,
code: vec![96, 16, 128, 96, 12, 96, 0, 57, 96, 0, 243, 0, 96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53, 85],
operations: vec![
- VMOperation { pc: 0, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 67976.into(), stack_push: vec_into![16], mem_diff: None, store_diff: None }) },
- VMOperation { pc: 2, instruction: 128, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 67973.into(), stack_push: vec_into![16, 16], mem_diff: None, store_diff: None }) },
- VMOperation { pc: 3, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 67970.into(), stack_push: vec_into![12], mem_diff: None, store_diff: None }) },
- VMOperation { pc: 5, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 67967.into(), stack_push: vec_into![0], mem_diff: None, store_diff: None }) },
- VMOperation { pc: 7, instruction: 57, gas_cost: 9.into(), executed: Some(VMExecutedOperation { gas_used: 67958.into(), stack_push: vec_into![], mem_diff: Some(MemoryDiff { offset: 0, data: vec![96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53] }), store_diff: None }) },
- VMOperation { pc: 8, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 67955.into(), stack_push: vec_into![0], mem_diff: None, store_diff: None }) },
+ VMOperation { pc: 0, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 67976.into(), stack_push: vec_into![16], mem_diff: None, store_diff: None }) },
+ VMOperation { pc: 2, instruction: 128, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 67973.into(), stack_push: vec_into![16, 16], mem_diff: None, store_diff: None }) },
+ VMOperation { pc: 3, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 67970.into(), stack_push: vec_into![12], mem_diff: None, store_diff: None }) },
+ VMOperation { pc: 5, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 67967.into(), stack_push: vec_into![0], mem_diff: None, store_diff: None }) },
+ VMOperation { pc: 7, instruction: 57, gas_cost: 9.into(), executed: Some(VMExecutedOperation { gas_used: 67958.into(), stack_push: vec_into![], mem_diff: Some(MemoryDiff { offset: 0, data: vec![96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53] }), store_diff: None }) },
+ VMOperation { pc: 8, instruction: 96, gas_cost: 3.into(), executed: Some(VMExecutedOperation { gas_used: 67955.into(), stack_push: vec_into![0], mem_diff: None, store_diff: None }) },
VMOperation { pc: 10, instruction: 243, gas_cost: 0.into(), executed: Some(VMExecutedOperation { gas_used: 67955.into(), stack_push: vec_into![], mem_diff: None, store_diff: None }) }
],
subs: vec![]
@@ -770,7 +770,7 @@ mod tests {
subs: vec![]
}];
assert_eq!(tracer.traces(), expected_trace);
-
+
let expected_vm_trace = VMTrace {
parent_step: 0,
code: vec![96, 16, 128, 96, 12, 96, 0, 57, 96, 0, 243, 0, 96, 0, 53, 84, 21, 96, 9, 87, 0, 91, 96, 32, 53, 96, 0, 53, 85],
diff --git a/ethcore/src/externalities.rs b/ethcore/src/externalities.rs
index 675d1904b..66509440a 100644
--- a/ethcore/src/externalities.rs
+++ b/ethcore/src/externalities.rs
@@ -203,7 +203,8 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
}
#[cfg_attr(feature="dev", allow(match_ref_pats))]
- fn ret(&mut self, gas: &U256, data: &[u8]) -> Result {
+ fn ret(mut self, gas: &U256, data: &[u8]) -> evm::Result
+ where Self: Sized {
let handle_copy = |to: &mut Option<&mut Bytes>| {
to.as_mut().map(|b| **b = data.to_owned());
};
@@ -212,20 +213,14 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
handle_copy(copy);
let len = cmp::min(slice.len(), data.len());
- unsafe {
- ptr::copy(data.as_ptr(), slice.as_mut_ptr(), len);
- }
+ (&mut slice[..len]).copy_from_slice(&data[..len]);
Ok(*gas)
},
OutputPolicy::Return(BytesRef::Flexible(ref mut vec), ref mut copy) => {
handle_copy(copy);
vec.clear();
- vec.reserve(data.len());
- unsafe {
- ptr::copy(data.as_ptr(), vec.as_mut_ptr(), data.len());
- vec.set_len(data.len());
- }
+ vec.extend_from_slice(data);
Ok(*gas)
},
OutputPolicy::InitContract(ref mut copy) => {
@@ -240,11 +235,8 @@ impl<'a, T, V> Ext for Externalities<'a, T, V> where T: 'a + Tracer, V: 'a + VMT
handle_copy(copy);
let mut code = vec![];
- code.reserve(data.len());
- unsafe {
- ptr::copy(data.as_ptr(), code.as_mut_ptr(), data.len());
- code.set_len(data.len());
- }
+ code.extend_from_slice(data);
+
self.state.init_code(&self.origin_info.address, code);
Ok(*gas - return_cost)
}
diff --git a/ethcore/src/json_tests/executive.rs b/ethcore/src/json_tests/executive.rs
index c5d781ab2..f4a34a33e 100644
--- a/ethcore/src/json_tests/executive.rs
+++ b/ethcore/src/json_tests/executive.rs
@@ -19,7 +19,7 @@ use state::*;
use executive::*;
use engine::*;
use evm;
-use evm::{Schedule, Ext, Factory, VMType, ContractCreateResult, MessageCallResult};
+use evm::{Schedule, Ext, Factory, Finalize, VMType, ContractCreateResult, MessageCallResult};
use externalities::*;
use substate::*;
use tests::helpers::*;
@@ -27,7 +27,7 @@ use ethjson;
use trace::{Tracer, NoopTracer};
use trace::{VMTracer, NoopVMTracer};
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Clone)]
struct CallCreate {
data: Bytes,
destination: Option,
@@ -133,7 +133,7 @@ impl<'a, T, V> Ext for TestExt<'a, T, V> where T: Tracer, V: VMTracer {
self.ext.log(topics, data)
}
- fn ret(&mut self, gas: &U256, data: &[u8]) -> Result {
+ fn ret(self, gas: &U256, data: &[u8]) -> Result {
self.ext.ret(gas, data)
}
@@ -208,9 +208,11 @@ fn do_json_test_for(vm_type: &VMType, json_data: &[u8]) -> Vec {
&mut tracer,
&mut vm_tracer,
);
- let evm = vm_factory.create();
+ let mut evm = vm_factory.create();
let res = evm.exec(params, &mut ex);
- (res, ex.callcreates)
+ // a return in finalize will not alter callcreates
+ let callcreates = ex.callcreates.clone();
+ (res.finalize(ex), callcreates)
};
match res {
diff --git a/ipc/codegen/src/codegen.rs b/ipc/codegen/src/codegen.rs
index 57db7d261..9dd6a7b32 100644
--- a/ipc/codegen/src/codegen.rs
+++ b/ipc/codegen/src/codegen.rs
@@ -392,16 +392,13 @@ fn implement_client_method_body(
});
request_serialization_statements.push(
- quote_stmt!(cx, let mut socket_ref = self.socket.borrow_mut()));
-
- request_serialization_statements.push(
- quote_stmt!(cx, let mut socket = socket_ref.deref_mut()));
+ quote_stmt!(cx, let mut socket = self.socket.write().unwrap(); ));
request_serialization_statements.push(
quote_stmt!(cx, let serialized_payload = ::ipc::binary::serialize(&payload).unwrap()));
request_serialization_statements.push(
- quote_stmt!(cx, ::ipc::invoke($index_ident, &Some(serialized_payload), &mut socket)));
+ quote_stmt!(cx, ::ipc::invoke($index_ident, &Some(serialized_payload), &mut *socket)));
request_serialization_statements
@@ -409,17 +406,15 @@ fn implement_client_method_body(
else {
let mut request_serialization_statements = Vec::new();
request_serialization_statements.push(
- quote_stmt!(cx, let mut socket_ref = self.socket.borrow_mut()));
+ quote_stmt!(cx, let mut socket = self.socket.write().unwrap(); ));
request_serialization_statements.push(
- quote_stmt!(cx, let mut socket = socket_ref.deref_mut()));
- request_serialization_statements.push(
- quote_stmt!(cx, ::ipc::invoke($index_ident, &None, &mut socket)));
+ quote_stmt!(cx, ::ipc::invoke($index_ident, &None, &mut *socket)));
request_serialization_statements
};
if let Some(ref return_ty) = dispatch.return_type_ty {
let return_expr = quote_expr!(cx,
- ::ipc::binary::deserialize_from::<$return_ty, _>(&mut socket).unwrap()
+ ::ipc::binary::deserialize_from::<$return_ty, _>(&mut *socket).unwrap()
);
quote_expr!(cx, {
$request
@@ -525,7 +520,7 @@ fn push_client_struct(cx: &ExtCtxt, builder: &aster::AstBuilder, interface_map:
let client_struct_item = quote_item!(cx,
pub struct $client_short_ident $generics {
- socket: ::std::cell::RefCell,
+ socket: ::std::sync::RwLock,
phantom: $phantom,
});
@@ -560,7 +555,7 @@ fn push_with_socket_client_implementation(
impl $generics ::ipc::WithSocket for $client_ident $where_clause {
fn init(socket: S) -> $client_ident {
$client_short_ident {
- socket: ::std::cell::RefCell::new(socket),
+ socket: ::std::sync::RwLock::new(socket),
phantom: ::std::marker::PhantomData,
}
}
@@ -594,15 +589,13 @@ fn push_client_implementation(
reserved: vec![0u8; 64],
};
- let mut socket_ref = self.socket.borrow_mut();
- let mut socket = socket_ref.deref_mut();
::ipc::invoke(
0,
&Some(::ipc::binary::serialize(&payload).unwrap()),
- &mut socket);
+ &mut *self.socket.write().unwrap());
let mut result = vec![0u8; 1];
- if try!(socket.read(&mut result).map_err(|_| ::ipc::Error::HandshakeFailed)) == 1 {
+ if try!(self.socket.write().unwrap().read(&mut result).map_err(|_| ::ipc::Error::HandshakeFailed)) == 1 {
match result[0] {
1 => Ok(()),
_ => Err(::ipc::Error::RemoteServiceUnsupported),
@@ -613,7 +606,7 @@ fn push_client_implementation(
let socket_item = quote_impl_item!(cx,
#[cfg(test)]
- pub fn socket(&self) -> &::std::cell::RefCell {
+ pub fn socket(&self) -> &::std::sync::RwLock {
&self.socket
}).unwrap();
diff --git a/ipc/codegen/src/serialization.rs b/ipc/codegen/src/serialization.rs
index c2e39ea33..b32c88b6d 100644
--- a/ipc/codegen/src/serialization.rs
+++ b/ipc/codegen/src/serialization.rs
@@ -230,6 +230,9 @@ fn binary_expr_struct(
let field_amount = builder.id(&format!("{}",fields.len()));
map_stmts.push(quote_stmt!(cx, let mut map = vec![0usize; $field_amount];).unwrap());
map_stmts.push(quote_stmt!(cx, let mut total = 0usize;).unwrap());
+
+ let mut post_write_stmts = Vec::::new();
+
for (index, field) in fields.iter().enumerate() {
let field_type_ident = builder.id(
&::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty)));
@@ -249,6 +252,7 @@ fn binary_expr_struct(
};
let raw_ident = ::syntax::print::pprust::ty_to_string(&codegen::strip_ptr(&field.ty));
+ let range_ident = builder.id(format!("r{}", index));
match raw_ident.as_ref() {
"u8" => {
write_stmts.push(quote_stmt!(cx, let next_line = offset + 1;).unwrap());
@@ -258,15 +262,17 @@ fn binary_expr_struct(
write_stmts.push(quote_stmt!(cx, let size = $member_expr .len();).unwrap());
write_stmts.push(quote_stmt!(cx, let next_line = offset + size;).unwrap());
write_stmts.push(quote_stmt!(cx, length_stack.push_back(size);).unwrap());
- write_stmts.push(quote_stmt!(cx, buffer[offset..next_line].clone_from_slice($member_expr); ).unwrap());
+ write_stmts.push(quote_stmt!(cx, let $range_ident = offset..next_line; ).unwrap());
+ post_write_stmts.push(quote_stmt!(cx, buffer[$range_ident].clone_from_slice($member_expr); ).unwrap());
}
_ => {
write_stmts.push(quote_stmt!(cx, let next_line = offset + match $field_type_ident_qualified::len_params() {
0 => mem::size_of::<$field_type_ident>(),
_ => { let size = $member_expr .size(); length_stack.push_back(size); size },
}).unwrap());
- write_stmts.push(quote_stmt!(cx,
- if let Err(e) = $member_expr .to_bytes(&mut buffer[offset..next_line], length_stack) { return Err(e) };).unwrap());
+ write_stmts.push(quote_stmt!(cx, let $range_ident = offset..next_line; ).unwrap());
+ post_write_stmts.push(quote_stmt!(cx,
+ if let Err(e) = $member_expr .to_bytes(&mut buffer[$range_ident], length_stack) { return Err(e) };).unwrap());
}
}
@@ -312,7 +318,7 @@ fn binary_expr_struct(
Ok(BinaryExpressions {
size: total_size_expr,
- write: quote_expr!(cx, { $write_stmts; Ok(()) } ),
+ write: quote_expr!(cx, { $write_stmts; $post_write_stmts; Ok(()) } ),
read: read_expr,
})
}
diff --git a/ipc/nano/src/lib.rs b/ipc/nano/src/lib.rs
index 964e52c68..38ff05c5b 100644
--- a/ipc/nano/src/lib.rs
+++ b/ipc/nano/src/lib.rs
@@ -30,6 +30,7 @@ use nanomsg::{Socket, Protocol, Error, Endpoint, PollRequest, PollFd, PollInOut}
use std::ops::Deref;
const POLL_TIMEOUT: isize = 100;
+const CLIENT_CONNECTION_TIMEOUT: isize = 2500;
/// Generic worker to handle service (binded) sockets
pub struct Worker where S: IpcInterface {
@@ -46,6 +47,12 @@ pub struct GuardedSocket where S: WithSocket {
_endpoint: Endpoint,
}
+impl GuardedSocket where S: WithSocket {
+ pub fn service(&self) -> Arc {
+ self.client.clone()
+ }
+}
+
impl Deref for GuardedSocket where S: WithSocket {
type Target = S;
@@ -63,6 +70,9 @@ pub fn init_duplex_client(socket_addr: &str) -> Result, Sock
SocketError::DuplexLink
}));
+ // 2500 ms default timeout
+ socket.set_receive_timeout(CLIENT_CONNECTION_TIMEOUT).unwrap();
+
let endpoint = try!(socket.connect(socket_addr).map_err(|e| {
warn!(target: "ipc", "Failed to bind socket to address '{}': {:?}", socket_addr, e);
SocketError::DuplexLink
@@ -83,6 +93,9 @@ pub fn init_client(socket_addr: &str) -> Result, SocketError
SocketError::RequestLink
}));
+ // 2500 ms default timeout
+ socket.set_receive_timeout(CLIENT_CONNECTION_TIMEOUT).unwrap();
+
let endpoint = try!(socket.connect(socket_addr).map_err(|e| {
warn!(target: "ipc", "Failed to bind socket to address '{}': {:?}", socket_addr, e);
SocketError::RequestLink
diff --git a/ipc/rpc/src/binary.rs b/ipc/rpc/src/binary.rs
index a985a2de9..62a3c43b0 100644
--- a/ipc/rpc/src/binary.rs
+++ b/ipc/rpc/src/binary.rs
@@ -104,14 +104,31 @@ impl BinaryConvertable for Result) -> Result<(), BinaryConvertError> {
match *self {
- Ok(ref r) => { buffer[0] = 0; Ok(try!(r.to_bytes(&mut buffer[1..], length_stack))) },
- Err(ref e) => { buffer[1] = 1; Ok(try!(e.to_bytes(&mut buffer[1..], length_stack))) },
+ Ok(ref r) => {
+ buffer[0] = 0;
+ if r.size() > 0 {
+ Ok(try!(r.to_bytes(&mut buffer[1..], length_stack)))
+ }
+ else { Ok(()) }
+ },
+ Err(ref e) => {
+ buffer[0] = 1;
+ if e.size() > 0 {
+ Ok(try!(e.to_bytes(&mut buffer[1..], length_stack)))
+ }
+ else { Ok(()) }
+ },
}
}
fn from_bytes(buffer: &[u8], length_stack: &mut VecDeque) -> Result {
match buffer[0] {
- 0 => Ok(Ok(try!(R::from_bytes(&buffer[1..], length_stack)))),
+ 0 => {
+ match buffer.len() {
+ 1 => Ok(Ok(try!(R::from_empty_bytes()))),
+ _ => Ok(Ok(try!(R::from_bytes(&buffer[1..], length_stack)))),
+ }
+ }
1 => Ok(Err(try!(E::from_bytes(&buffer[1..], length_stack)))),
_ => Err(BinaryConvertError)
}
@@ -154,6 +171,8 @@ impl BinaryConvertable for Vec where T: BinaryConvertable {
_ => 128,
});
+ if buffer.len() == 0 { return Ok(result); }
+
loop {
let next_size = match T::len_params() {
0 => mem::size_of::(),
@@ -300,8 +319,8 @@ pub fn deserialize_from(r: &mut R) -> Result
let mut payload = Vec::new();
try!(r.read_to_end(&mut payload).map_err(|_| BinaryConvertError));
- let mut length_stack = VecDeque::::new();
let stack_len = try!(u64::from_bytes(&payload[0..8], &mut fake_stack)) as usize;
+ let mut length_stack = VecDeque::::with_capacity(stack_len);
if stack_len > 0 {
for idx in 0..stack_len {
@@ -607,7 +626,7 @@ fn deserialize_simple_err() {
}
#[test]
-fn deserialize_opt_vec_in_out() {
+fn serialize_opt_vec_in_out() {
use std::io::{Cursor, SeekFrom, Seek};
let mut buff = Cursor::new(Vec::new());
@@ -619,3 +638,17 @@ fn deserialize_opt_vec_in_out() {
assert!(vec.is_none());
}
+
+#[test]
+fn serialize_err_opt_vec_in_out() {
+ use std::io::{Cursor, SeekFrom, Seek};
+
+ let mut buff = Cursor::new(Vec::new());
+ let optional_vec: Result