diff --git a/Cargo.lock b/Cargo.lock index 723bca872..ccffed5b7 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)", @@ -868,7 +869,7 @@ dependencies = [ [[package]] name = "parity-dapps-builtins" version = "0.5.0" -source = "git+https://github.com/ethcore/parity-dapps-builtins-rs.git#eb86a2954f04d3aa5547a8c4bb77ae7aad09bf55" +source = "git+https://github.com/ethcore/parity-dapps-builtins-rs.git#8bbf0421e376f9496d70adc62c1c6d7f492df817" dependencies = [ "parity-dapps 0.3.0 (git+https://github.com/ethcore/parity-dapps-rs.git)", ] diff --git a/cov.sh b/cov.sh index 084e95284..a13db50b9 100755 --- a/cov.sh +++ b/cov.sh @@ -22,7 +22,6 @@ cargo test \ -p ethsync \ -p ethcore-rpc \ -p parity \ - -p ethminer \ -p ethcore-signer \ -p ethcore-dapps \ --no-run || exit $? @@ -37,5 +36,4 @@ kcov --exclude-pattern $EXCLUDE --include-pattern src --verify target/coverage t kcov --exclude-pattern $EXCLUDE --include-pattern src --verify target/coverage target/debug/deps/ethcore_rpc-* kcov --exclude-pattern $EXCLUDE --include-pattern src --verify target/coverage target/debug/deps/ethcore_signer-* kcov --exclude-pattern $EXCLUDE --include-pattern src --verify target/coverage target/debug/deps/ethcore_dapps-* -kcov --exclude-pattern $EXCLUDE --include-pattern src --verify target/coverage target/debug/deps/ethminer-* xdg-open target/coverage/index.html 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/doc.sh b/doc.sh index 0b75f6c38..fb39ef272 100755 --- a/doc.sh +++ b/doc.sh @@ -10,4 +10,3 @@ cargo doc --no-deps --verbose \ -p ethcore-signer \ -p ethcore-dapps \ -p parity \ - -p ethminer 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/hook.sh b/hook.sh index 978f0ca23..adb763f9d 100755 --- a/hook.sh +++ b/hook.sh @@ -7,6 +7,6 @@ echo "set -e" >> $FILE echo "cargo build --features dev" >> $FILE # Build tests echo "cargo test --no-run --features dev \\" >> $FILE -echo " -p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity -p ethminer -p ethcore-dapps -p ethcore-signer" >> $FILE +echo " -p ethash -p ethcore-util -p ethcore -p ethsync -p ethcore-rpc -p parity -p ethcore-dapps -p ethcore-signer" >> $FILE echo "" >> $FILE chmod +x $FILE 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>, u32> = Ok(None); + serialize_into(&optional_vec, &mut buff).unwrap(); + + buff.seek(SeekFrom::Start(0)).unwrap(); + let vec = deserialize_from::>, u32>, _>(&mut buff).unwrap(); + + assert!(vec.is_ok()); +} diff --git a/parity/cli.rs b/parity/cli.rs index 95b77a00d..bb67ee5c6 100644 --- a/parity/cli.rs +++ b/parity/cli.rs @@ -96,6 +96,8 @@ API and Console Options: asked for password on startup. --dapps-pass PASSWORD Specify password for Dapps server. Use only in conjunction with --dapps-user. + --dapps-path PATH Specify directory where dapps should be installed. + [default: $HOME/.parity/dapps] --signer Enable Trusted Signer WebSocket endpoint used by System UIs. @@ -239,6 +241,7 @@ pub struct Args { pub flag_dapps_interface: String, pub flag_dapps_user: Option, pub flag_dapps_pass: Option, + pub flag_dapps_path: String, pub flag_signer: bool, pub flag_signer_port: u16, pub flag_force_sealing: bool, diff --git a/parity/configuration.rs b/parity/configuration.rs index 61a571ae1..6185d2cf7 100644 --- a/parity/configuration.rs +++ b/parity/configuration.rs @@ -40,6 +40,7 @@ pub struct Configuration { pub struct Directories { pub keys: String, pub db: String, + pub dapps: String, } impl Configuration { @@ -325,11 +326,14 @@ impl Configuration { &self.args.flag_keys_path } ); - ::std::fs::create_dir_all(&db_path).unwrap_or_else(|e| die_with_io_error("main", e)); + ::std::fs::create_dir_all(&keys_path).unwrap_or_else(|e| die_with_io_error("main", e)); + let dapps_path = Configuration::replace_home(&self.args.flag_dapps_path); + ::std::fs::create_dir_all(&dapps_path).unwrap_or_else(|e| die_with_io_error("main", e)); Directories { keys: keys_path, db: db_path, + dapps: dapps_path, } } diff --git a/parity/dapps.rs b/parity/dapps.rs index 91742d9e3..59a9ee552 100644 --- a/parity/dapps.rs +++ b/parity/dapps.rs @@ -32,6 +32,7 @@ pub struct Configuration { pub port: u16, pub user: Option, pub pass: Option, + pub dapps_path: String, } pub struct Dependencies { @@ -63,12 +64,13 @@ pub fn new(configuration: Configuration, deps: Dependencies) -> Option, ) -> ! { @@ -78,12 +80,13 @@ pub fn setup_dapps_server( #[cfg(feature = "dapps")] pub fn setup_dapps_server( deps: Dependencies, + dapps_path: String, url: &SocketAddr, auth: Option<(String, String)> ) -> WebappServer { use ethcore_dapps as dapps; - let server = dapps::ServerBuilder::new(); + let server = dapps::ServerBuilder::new(dapps_path); let server = rpc_apis::setup_rpc(server, deps.apis.clone(), rpc_apis::ApiSet::UnsafeContext); let start_result = match auth { None => { diff --git a/parity/main.rs b/parity/main.rs index ca5e39a1a..74d14bfd6 100644 --- a/parity/main.rs +++ b/parity/main.rs @@ -231,6 +231,7 @@ fn execute_client(conf: Configuration, spec: Spec, client_config: ClientConfig) port: conf.args.flag_dapps_port, user: conf.args.flag_dapps_user.clone(), pass: conf.args.flag_dapps_pass.clone(), + dapps_path: conf.directories().dapps, }, dapps::Dependencies { panic_handler: panic_handler.clone(), apis: deps_for_rpc_apis.clone(), diff --git a/parity/signer.rs b/parity/signer.rs index d549b89cb..a7de993fb 100644 --- a/parity/signer.rs +++ b/parity/signer.rs @@ -51,7 +51,7 @@ fn do_start(conf: Configuration, deps: Dependencies) -> SignerServer { }); let start_result = { - let server = signer::ServerBuilder::new(); + let server = signer::ServerBuilder::new(deps.apis.signer_queue.clone()); let server = rpc_apis::setup_rpc(server, deps.apis, rpc_apis::ApiSet::SafeContext); server.start(addr) }; diff --git a/rpc/src/v1/helpers/signing_queue.rs b/rpc/src/v1/helpers/signing_queue.rs index eee4328ee..0ded8998c 100644 --- a/rpc/src/v1/helpers/signing_queue.rs +++ b/rpc/src/v1/helpers/signing_queue.rs @@ -14,78 +14,281 @@ // You should have received a copy of the GNU General Public License // along with Parity. If not, see . -use std::sync::Mutex; +use std::thread; +use std::time::{Instant, Duration}; +use std::sync::{mpsc, Mutex, RwLock, Arc}; use std::collections::HashMap; use v1::types::{TransactionRequest, TransactionConfirmation}; -use util::U256; +use util::{U256, H256}; + + +/// Possible events happening in the queue that can be listened to. +#[derive(Debug, PartialEq)] +pub enum QueueEvent { + /// Receiver should stop work upon receiving `Finish` message. + Finish, + /// Informs about new request. + NewRequest(U256), + /// Request rejected. + RequestRejected(U256), + /// Request resolved. + RequestConfirmed(U256), +} + +/// Defines possible errors returned from queue receiving method. +#[derive(Debug, PartialEq)] +pub enum QueueError { + /// Returned when method has been already used (no receiver available). + AlreadyUsed, + /// Returned when receiver encounters an error. + ReceiverError(mpsc::RecvError), +} + +/// Message Receiver type +pub type QueueEventReceiver = mpsc::Receiver; /// A queue of transactions awaiting to be confirmed and signed. pub trait SigningQueue: Send + Sync { /// Add new request to the queue. - fn add_request(&self, transaction: TransactionRequest) -> U256; + /// Returns a `ConfirmationPromise` that can be used to await for resolution of given request. + fn add_request(&self, transaction: TransactionRequest) -> ConfirmationPromise; - /// Remove request from the queue. - fn remove_request(&self, id: U256) -> Option; + /// Removes a request from the queue. + /// Notifies possible token holders that transaction was rejected. + fn request_rejected(&self, id: U256) -> Option; + + /// Removes a request from the queue. + /// Notifies possible token holders that transaction was confirmed and given hash was assigned. + fn request_confirmed(&self, id: U256, hash: H256) -> Option; + + /// Returns a request if it is contained in the queue. + fn peek(&self, id: &U256) -> Option; /// Return copy of all the requests in the queue. fn requests(&self) -> Vec; } -/// Queue for all unconfirmed transactions. -pub struct ConfirmationsQueue { - id: Mutex, - queue: Mutex>, +#[derive(Debug, PartialEq)] +enum ConfirmationResult { + /// The transaction has not yet been confirmed nor rejected. + Waiting, + /// The transaction has been rejected. + Rejected, + /// The transaction has been confirmed. + Confirmed(H256), } -impl Default for ConfirmationsQueue { - fn default() -> Self { - ConfirmationsQueue { - id: Mutex::new(U256::from(0)), - queue: Mutex::new(HashMap::new()), +/// Time you need to confirm the transaction in UI. +/// This is the amount of time token holder will wait before +/// returning `None`. +/// Unless we have a multi-threaded RPC this will lock +/// any other incoming call! +const QUEUE_TIMEOUT_DURATION_SEC : u64 = 20; + +/// A handle to submitted request. +/// Allows to block and wait for a resolution of that request. +pub struct ConfirmationToken { + result: Arc>, + handle: thread::Thread, + request: TransactionConfirmation, +} + +pub struct ConfirmationPromise { + id: U256, + result: Arc>, +} + +impl ConfirmationToken { + /// Submit solution to all listeners + fn resolve(&self, result: Option) { + let mut res = self.result.lock().unwrap(); + *res = result.map_or(ConfirmationResult::Rejected, |h| ConfirmationResult::Confirmed(h)); + // Notify listener + self.handle.unpark(); + } + + fn as_promise(&self) -> ConfirmationPromise { + ConfirmationPromise { + id: self.request.id, + result: self.result.clone(), } } } -impl SigningQueue for ConfirmationsQueue { - fn add_request(&self, transaction: TransactionRequest) -> U256 { +impl ConfirmationPromise { + /// Blocks current thread and awaits for + /// resolution of the transaction (rejected / confirmed) + /// Returns `None` if transaction was rejected or timeout reached. + /// Returns `Some(hash)` if transaction was confirmed. + pub fn wait_with_timeout(&self) -> Option { + let timeout = Duration::from_secs(QUEUE_TIMEOUT_DURATION_SEC); + let deadline = Instant::now() + timeout; + + info!(target: "own_tx", "Signer: Awaiting transaction confirmation... ({:?}).", self.id); + loop { + let now = Instant::now(); + if now >= deadline { + break; + } + // Park thread (may wake up spuriously) + thread::park_timeout(deadline - now); + // Take confirmation result + let res = self.result.lock().unwrap(); + // Check the result + match *res { + ConfirmationResult::Rejected => return None, + ConfirmationResult::Confirmed(h) => return Some(h), + ConfirmationResult::Waiting => continue, + } + } + // We reached the timeout. Just return `None` + trace!(target: "own_tx", "Signer: Confirmation timeout reached... ({:?}).", self.id); + None + } +} + +/// Queue for all unconfirmed transactions. +pub struct ConfirmationsQueue { + id: Mutex, + queue: RwLock>, + sender: Mutex>, + receiver: Mutex>>, +} + +impl Default for ConfirmationsQueue { + fn default() -> Self { + let (send, recv) = mpsc::channel(); + + ConfirmationsQueue { + id: Mutex::new(U256::from(0)), + queue: RwLock::new(HashMap::new()), + sender: Mutex::new(send), + receiver: Mutex::new(Some(recv)), + } + } +} + +impl ConfirmationsQueue { + /// Blocks the thread and starts listening for notifications regarding all actions in the queue. + /// For each event, `listener` callback will be invoked. + /// This method can be used only once (only single consumer of events can exist). + pub fn start_listening(&self, listener: F) -> Result<(), QueueError> + where F: Fn(QueueEvent) -> () { + let recv = self.receiver.lock().unwrap().take(); + if let None = recv { + return Err(QueueError::AlreadyUsed); + } + let recv = recv.expect("Check for none is done earlier."); + + loop { + let message = try!(recv.recv().map_err(|e| QueueError::ReceiverError(e))); + if let QueueEvent::Finish = message { + return Ok(()); + } + + listener(message); + } + } + + /// Notifies consumer that the communcation is over. + /// No more events will be sent after this function is invoked. + pub fn finish(&self) { + self.notify(QueueEvent::Finish); + } + + /// Notifies receiver about the event happening in this queue. + fn notify(&self, message: QueueEvent) { + // We don't really care about the result + let _ = self.sender.lock().unwrap().send(message); + } + + /// Removes transaction from this queue and notifies `ConfirmationPromise` holders about the result. + /// Notifies also a receiver about that event. + fn remove(&self, id: U256, result: Option) -> Option { + let token = self.queue.write().unwrap().remove(&id); + + if let Some(token) = token { + // notify receiver about the event + self.notify(result.map_or_else( + || QueueEvent::RequestRejected(id), + |_| QueueEvent::RequestConfirmed(id) + )); + // notify token holders about resolution + token.resolve(result); + // return a result + return Some(token.request.clone()); + } + None + } +} + +impl Drop for ConfirmationsQueue { + fn drop(&mut self) { + self.finish(); + } +} + +impl SigningQueue for ConfirmationsQueue { + fn add_request(&self, transaction: TransactionRequest) -> ConfirmationPromise { // Increment id let id = { let mut last_id = self.id.lock().unwrap(); *last_id = *last_id + U256::from(1); *last_id }; - let mut queue = self.queue.lock().unwrap(); - queue.insert(id, TransactionConfirmation { - id: id, - transaction: transaction, - }); - id + // Add request to queue + let res = { + let mut queue = self.queue.write().unwrap(); + queue.insert(id, ConfirmationToken { + result: Arc::new(Mutex::new(ConfirmationResult::Waiting)), + handle: thread::current(), + request: TransactionConfirmation { + id: id, + transaction: transaction, + }, + }); + debug!(target: "own_tx", "Signer: New transaction ({:?}) in confirmation queue.", id); + queue.get(&id).map(|token| token.as_promise()).expect("Token was just inserted.") + }; + // Notify listeners + self.notify(QueueEvent::NewRequest(id)); + res + } - fn remove_request(&self, id: U256) -> Option { - self.queue.lock().unwrap().remove(&id) + fn peek(&self, id: &U256) -> Option { + self.queue.read().unwrap().get(id).map(|token| token.request.clone()) + } + + fn request_rejected(&self, id: U256) -> Option { + debug!(target: "own_tx", "Signer: Transaction rejected ({:?}).", id); + self.remove(id, None) + } + + fn request_confirmed(&self, id: U256, hash: H256) -> Option { + debug!(target: "own_tx", "Signer: Transaction confirmed ({:?}).", id); + self.remove(id, Some(hash)) } fn requests(&self) -> Vec { - let queue = self.queue.lock().unwrap(); - queue.values().cloned().collect() + let queue = self.queue.read().unwrap(); + queue.values().map(|token| token.request.clone()).collect() } } #[cfg(test)] mod test { + use std::time::Duration; + use std::thread; + use std::sync::{Arc, Mutex}; use util::hash::Address; - use util::numbers::U256; + use util::numbers::{U256, H256}; use v1::types::TransactionRequest; use super::*; - #[test] - fn should_work_for_hashset() { - // given - let queue = ConfirmationsQueue::default(); - - let request = TransactionRequest { + fn request() -> TransactionRequest { + TransactionRequest { from: Address::from(1), to: Some(Address::from(2)), gas_price: None, @@ -93,7 +296,63 @@ mod test { value: Some(U256::from(10_000_000)), data: None, nonce: None, - }; + } + } + + #[test] + fn should_wait_for_hash() { + // given + let queue = Arc::new(ConfirmationsQueue::default()); + let request = request(); + + // when + let q = queue.clone(); + let handle = thread::spawn(move || { + let v = q.add_request(request); + v.wait_with_timeout().expect("Should return hash") + }); + + let id = U256::from(1); + while queue.peek(&id).is_none() { + // Just wait for the other thread to start + thread::sleep(Duration::from_millis(100)); + } + queue.request_confirmed(id, H256::from(1)); + + // then + assert_eq!(handle.join().expect("Thread should finish nicely"), H256::from(1)); + } + + #[test] + fn should_receive_notification() { + // given + let received = Arc::new(Mutex::new(None)); + let queue = Arc::new(ConfirmationsQueue::default()); + let request = request(); + + // when + let q = queue.clone(); + let r = received.clone(); + let handle = thread::spawn(move || { + q.start_listening(move |notification| { + let mut v = r.lock().unwrap(); + *v = Some(notification); + }).expect("Should be closed nicely.") + }); + queue.add_request(request); + queue.finish(); + + // then + handle.join().expect("Thread should finish nicely"); + let r = received.lock().unwrap().take(); + assert_eq!(r, Some(QueueEvent::NewRequest(U256::from(1)))); + } + + #[test] + fn should_add_transactions() { + // given + let queue = ConfirmationsQueue::default(); + let request = request(); // when queue.add_request(request.clone()); diff --git a/rpc/src/v1/impls/eth.rs b/rpc/src/v1/impls/eth.rs index 5c205c087..b0d6abcf0 100644 --- a/rpc/src/v1/impls/eth.rs +++ b/rpc/src/v1/impls/eth.rs @@ -499,7 +499,7 @@ impl Eth for EthClient where .and_then(|(raw_transaction, )| { let raw_transaction = raw_transaction.to_vec(); match UntrustedRlp::new(&raw_transaction).as_val() { - Ok(signed_transaction) => dispatch_transaction(&*take_weak!(self.client), &*take_weak!(self.miner), signed_transaction), + Ok(signed_transaction) => to_value(&dispatch_transaction(&*take_weak!(self.client), &*take_weak!(self.miner), signed_transaction)), Err(_) => to_value(&H256::zero()), } }) diff --git a/rpc/src/v1/impls/eth_filter.rs b/rpc/src/v1/impls/eth_filter.rs index 4f44f5193..b34a4f703 100644 --- a/rpc/src/v1/impls/eth_filter.rs +++ b/rpc/src/v1/impls/eth_filter.rs @@ -169,8 +169,9 @@ impl EthFilter for EthFilterClient where logs.extend(new_pending_logs); } - // save current block number as next from block number - *block_number = current_number; + // save the number of the next block as a first block from which + // we want to get logs + *block_number = current_number + 1; to_value(&logs) } diff --git a/rpc/src/v1/impls/eth_signing.rs b/rpc/src/v1/impls/eth_signing.rs index f0973484f..f8c3c343d 100644 --- a/rpc/src/v1/impls/eth_signing.rs +++ b/rpc/src/v1/impls/eth_signing.rs @@ -53,9 +53,9 @@ impl EthSigning for EthSigningQueueClient { from_params::<(TransactionRequest, )>(params) .and_then(|(request, )| { let queue = take_weak!(self.queue); - queue.add_request(request); - // TODO [ToDr] Block and wait for confirmation? - to_value(&H256::zero()) + let id = queue.add_request(request); + let result = id.wait_with_timeout(); + to_value(&result.unwrap_or_else(H256::new)) }) } } @@ -102,7 +102,7 @@ impl EthSigning for EthSigningUnsafeClient where .and_then(|(request, )| { let accounts = take_weak!(self.accounts); match accounts.account_secret(&request.from) { - Ok(secret) => sign_and_dispatch(&self.client, &self.miner, request, secret), + Ok(secret) => to_value(&sign_and_dispatch(&*take_weak!(self.client), &*take_weak!(self.miner), request, secret)), Err(_) => to_value(&H256::zero()) } }) diff --git a/rpc/src/v1/impls/mod.rs b/rpc/src/v1/impls/mod.rs index 33c434122..9e154a1c5 100644 --- a/rpc/src/v1/impls/mod.rs +++ b/rpc/src/v1/impls/mod.rs @@ -52,16 +52,14 @@ pub use self::traces::TracesClient; pub use self::rpc::RpcClient; use v1::types::TransactionRequest; -use std::sync::Weak; use ethcore::miner::{AccountDetails, MinerService}; use ethcore::client::MiningBlockChainClient; use ethcore::transaction::{Action, SignedTransaction, Transaction}; use util::numbers::*; use util::rlp::encode; use util::bytes::ToPretty; -use jsonrpc_core::{Error, to_value, Value}; -fn dispatch_transaction(client: &C, miner: &M, signed_transaction: SignedTransaction) -> Result +fn dispatch_transaction(client: &C, miner: &M, signed_transaction: SignedTransaction) -> H256 where C: MiningBlockChainClient, M: MinerService { let hash = signed_transaction.hash(); @@ -72,13 +70,11 @@ fn dispatch_transaction(client: &C, miner: &M, signed_transaction: SignedT } }); - to_value(&import.map(|_| hash).unwrap_or(H256::zero())) + import.map(|_| hash).unwrap_or(H256::zero()) } -fn sign_and_dispatch(client: &Weak, miner: &Weak, request: TransactionRequest, secret: H256) -> Result +fn sign_and_dispatch(client: &C, miner: &M, request: TransactionRequest, secret: H256) -> H256 where C: MiningBlockChainClient, M: MinerService { - let client = take_weak!(client); - let miner = take_weak!(miner); let signed_transaction = { Transaction { diff --git a/rpc/src/v1/impls/personal.rs b/rpc/src/v1/impls/personal.rs index e5c3cd1a5..93d13aed7 100644 --- a/rpc/src/v1/impls/personal.rs +++ b/rpc/src/v1/impls/personal.rs @@ -83,7 +83,7 @@ impl Personal for PersonalClient .and_then(|(request, password)| { let accounts = take_weak!(self.accounts); match accounts.locked_account_secret(&request.from, &password) { - Ok(secret) => sign_and_dispatch(&self.client, &self.miner, request, secret), + Ok(secret) => to_value(&sign_and_dispatch(&*take_weak!(self.client), &*take_weak!(self.miner), request, secret)), Err(_) => to_value(&H256::zero()), } }) diff --git a/rpc/src/v1/impls/personal_signer.rs b/rpc/src/v1/impls/personal_signer.rs index 2d52e07f9..148330ced 100644 --- a/rpc/src/v1/impls/personal_signer.rs +++ b/rpc/src/v1/impls/personal_signer.rs @@ -63,19 +63,27 @@ impl PersonalSigner for SignerClient Some(sign_and_dispatch(&self.client, &self.miner, request, secret)), + Ok(secret) => { + let hash = sign_and_dispatch(&*client, &*miner, request, secret); + queue.request_confirmed(id, hash); + Some(to_value(&hash)) + }, Err(_) => None } }) - .unwrap_or_else(|| to_value(&H256::zero())) + .unwrap_or_else(|| { + queue.request_rejected(id); + to_value(&H256::zero()) + }) } ) } @@ -84,7 +92,7 @@ impl PersonalSigner for SignerClient(params).and_then( |(id, )| { let queue = take_weak!(self.queue); - let res = queue.remove_request(id); + let res = queue.request_rejected(id); to_value(&res.is_some()) } ) diff --git a/signer/src/lib.rs b/signer/src/lib.rs index e2df72bcc..8391d42b4 100644 --- a/signer/src/lib.rs +++ b/signer/src/lib.rs @@ -30,12 +30,15 @@ //! //! ``` //! extern crate ethcore_signer; +//! extern crate ethcore_rpc; //! +//! use std::sync::Arc; //! use ethcore_signer::ServerBuilder; +//! use ethcore_rpc::ConfirmationsQueue; //! //! fn main() { -//! let builder = ServerBuilder::new(); -//! let _server = builder.start("127.0.0.1:8084".parse().unwrap()).unwrap(); +//! let queue = Arc::new(ConfirmationsQueue::default()); +//! let _server = ServerBuilder::new(queue).start("127.0.0.1:8084".parse().unwrap()); //! } //! ``` diff --git a/signer/src/ws_server/mod.rs b/signer/src/ws_server/mod.rs index bc8fb33f8..c987d7a87 100644 --- a/signer/src/ws_server/mod.rs +++ b/signer/src/ws_server/mod.rs @@ -25,7 +25,7 @@ use std::sync::Arc; use std::net::SocketAddr; use util::panics::{PanicHandler, OnPanicListener, MayPanic}; use jsonrpc_core::{IoHandler, IoDelegate}; -use rpc::Extendable; +use rpc::{Extendable, ConfirmationsQueue}; mod session; @@ -49,15 +49,10 @@ impl From for ServerError { /// Builder for `WebSockets` server pub struct ServerBuilder { + queue: Arc, handler: Arc, } -impl Default for ServerBuilder { - fn default() -> Self { - ServerBuilder::new() - } -} - impl Extendable for ServerBuilder { fn add_delegate(&self, delegate: IoDelegate) { self.handler.add_delegate(delegate); @@ -66,30 +61,32 @@ impl Extendable for ServerBuilder { impl ServerBuilder { /// Creates new `ServerBuilder` - pub fn new() -> Self { + pub fn new(queue: Arc) -> Self { ServerBuilder { - handler: Arc::new(IoHandler::new()) + queue: queue, + handler: Arc::new(IoHandler::new()), } } /// Starts a new `WebSocket` server in separate thread. /// Returns a `Server` handle which closes the server when droped. pub fn start(self, addr: SocketAddr) -> Result { - Server::start(addr, self.handler) + Server::start(addr, self.handler, self.queue) } } /// `WebSockets` server implementation. pub struct Server { handle: Option>>, - broadcaster: ws::Sender, + broadcaster_handle: Option>, + queue: Arc, panic_handler: Arc, } impl Server { /// Starts a new `WebSocket` server in separate thread. /// Returns a `Server` handle which closes the server when droped. - pub fn start(addr: SocketAddr, handler: Arc) -> Result { + fn start(addr: SocketAddr, handler: Arc, queue: Arc) -> Result { let config = { let mut config = ws::Settings::default(); config.max_connections = 5; @@ -103,6 +100,7 @@ impl Server { let panic_handler = PanicHandler::new_in_arc(); let ph = panic_handler.clone(); let broadcaster = ws.broadcaster(); + // Spawn a thread with event loop let handle = thread::spawn(move || { ph.catch_panic(move || { @@ -110,10 +108,24 @@ impl Server { }).unwrap() }); + // Spawn a thread for broadcasting + let ph = panic_handler.clone(); + let q = queue.clone(); + let broadcaster_handle = thread::spawn(move || { + ph.catch_panic(move || { + q.start_listening(|_message| { + // TODO [ToDr] Some better structure here for messages. + broadcaster.send("new_message").unwrap(); + }).expect("It's the only place we are running start_listening. It shouldn't fail."); + broadcaster.shutdown().expect("Broadcaster should close gently.") + }).unwrap() + }); + // Return a handle Ok(Server { handle: Some(handle), - broadcaster: broadcaster, + broadcaster_handle: Some(broadcaster_handle), + queue: queue, panic_handler: panic_handler, }) } @@ -127,7 +139,8 @@ impl MayPanic for Server { impl Drop for Server { fn drop(&mut self) { - self.broadcaster.shutdown().expect("WsServer should close nicely."); + self.queue.finish(); + self.broadcaster_handle.take().unwrap().join().unwrap(); self.handle.take().unwrap().join().unwrap(); } }