// Copyright 2015-2017 Parity Technologies (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 . #[macro_use] extern crate mime; extern crate multihash; extern crate cid; extern crate rlp; extern crate ethcore; extern crate ethcore_util as util; extern crate jsonrpc_http_server as http; pub mod error; mod route; use std::io::Write; use std::sync::Arc; use std::net::{SocketAddr, IpAddr}; use error::ServerError; use route::Out; use http::hyper::server::{Handler, Request, Response}; use http::hyper::net::HttpStream; use http::hyper::header::{self, Vary, ContentLength, ContentType}; use http::hyper::{Next, Encoder, Decoder, Method, RequestUri, StatusCode}; use ethcore::client::BlockChainClient; pub use http::hyper::server::Listening; pub use http::{AccessControlAllowOrigin, Host, DomainsValidation}; /// Request/response handler pub struct IpfsHandler { /// Response to send out out: Out, /// How many bytes from the response have been written out_progress: usize, /// CORS response header cors_header: Option, /// Allowed CORS domains cors_domains: Option>, /// Hostnames allowed in the `Host` request header allowed_hosts: Option>, /// Reference to the Blockchain Client client: Arc, } impl IpfsHandler { pub fn client(&self) -> &BlockChainClient { &*self.client } pub fn new(cors: DomainsValidation, hosts: DomainsValidation, client: Arc) -> Self { IpfsHandler { out: Out::Bad("Invalid Request"), out_progress: 0, cors_header: None, cors_domains: cors.into(), allowed_hosts: hosts.into(), client: client, } } } /// Implement Hyper's HTTP handler impl Handler for IpfsHandler { fn on_request(&mut self, req: Request) -> Next { if *req.method() != Method::Get { return Next::write(); } if !http::is_host_allowed(&req, &self.allowed_hosts) { self.out = Out::Bad("Disallowed Host header"); return Next::write(); } let cors_header = http::cors_header(&req, &self.cors_domains); if cors_header == http::CorsHeader::Invalid { self.out = Out::Bad("Disallowed Origin header"); return Next::write(); } self.cors_header = cors_header.into(); let (path, query) = match *req.uri() { RequestUri::AbsolutePath { ref path, ref query } => (path, query.as_ref().map(AsRef::as_ref)), _ => return Next::write(), }; self.out = self.route(path, query); Next::write() } fn on_request_readable(&mut self, _decoder: &mut Decoder) -> Next { Next::write() } fn on_response(&mut self, res: &mut Response) -> Next { use Out::*; match self.out { OctetStream(ref bytes) => { use mime::{Mime, TopLevel, SubLevel}; // `OctetStream` is not a valid variant, so need to construct // the type manually. let content_type = Mime( TopLevel::Application, SubLevel::Ext("octet-stream".into()), vec![] ); res.headers_mut().set(ContentLength(bytes.len() as u64)); res.headers_mut().set(ContentType(content_type)); }, NotFound(reason) => { res.set_status(StatusCode::NotFound); res.headers_mut().set(ContentLength(reason.len() as u64)); res.headers_mut().set(ContentType(mime!(Text/Plain))); }, Bad(reason) => { res.set_status(StatusCode::BadRequest); res.headers_mut().set(ContentLength(reason.len() as u64)); res.headers_mut().set(ContentType(mime!(Text/Plain))); } } if let Some(cors_header) = self.cors_header.take() { res.headers_mut().set(cors_header); res.headers_mut().set(Vary::Items(vec!["Origin".into()])); } Next::write() } fn on_response_writable(&mut self, transport: &mut Encoder) -> Next { use Out::*; // Get the data to write as a byte slice let data = match self.out { OctetStream(ref bytes) => &bytes, NotFound(reason) | Bad(reason) => reason.as_bytes(), }; write_chunk(transport, &mut self.out_progress, data) } } /// Attempt to write entire `data` from current `progress` fn write_chunk(transport: &mut W, progress: &mut usize, data: &[u8]) -> Next { // Skip any bytes that have already been written let chunk = &data[*progress..]; // Write an get the amount of bytes written. End the connection in case of an error. let written = match transport.write(chunk) { Ok(written) => written, Err(_) => return Next::end(), }; *progress += written; // Close the connection if the entire remaining chunk has been written if written < chunk.len() { Next::write() } else { Next::end() } } /// Add current interface (default: "127.0.0.1:5001") to list of allowed hosts fn include_current_interface(mut hosts: Vec, interface: String, port: u16) -> Vec { hosts.push(match port { 80 => interface, _ => format!("{}:{}", interface, port), }.into()); hosts } pub fn start_server( port: u16, interface: String, cors: DomainsValidation, hosts: DomainsValidation, client: Arc ) -> Result { let ip: IpAddr = interface.parse().map_err(|_| ServerError::InvalidInterface)?; let addr = SocketAddr::new(ip, port); let hosts: Option> = hosts.into(); let hosts: DomainsValidation<_> = hosts.map(move |hosts| include_current_interface(hosts, interface, port)).into(); Ok( http::hyper::Server::http(&addr)? .handle(move |_| IpfsHandler::new(cors.clone(), hosts.clone(), client.clone())) .map(|(listening, srv)| { ::std::thread::spawn(move || { srv.run(); }); listening })? ) } #[cfg(test)] mod tests { use super::*; #[test] fn write_chunk_to_vec() { let mut transport = Vec::new(); let mut progress = 0; let _ = write_chunk(&mut transport, &mut progress, b"foobar"); assert_eq!(b"foobar".to_vec(), transport); assert_eq!(6, progress); } #[test] fn write_chunk_to_vec_part() { let mut transport = Vec::new(); let mut progress = 3; let _ = write_chunk(&mut transport, &mut progress, b"foobar"); assert_eq!(b"bar".to_vec(), transport); assert_eq!(6, progress); } #[test] fn write_chunk_to_array() { use std::io::Cursor; let mut buf = [0u8; 3]; let mut progress = 0; { let mut transport: Cursor<&mut [u8]> = Cursor::new(&mut buf); let _ = write_chunk(&mut transport, &mut progress, b"foobar"); } assert_eq!(*b"foo", buf); assert_eq!(3, progress); { let mut transport: Cursor<&mut [u8]> = Cursor::new(&mut buf); let _ = write_chunk(&mut transport, &mut progress, b"foobar"); } assert_eq!(*b"bar", buf); assert_eq!(6, progress); } }