tyler
/
proxmox-backup
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
proxmox-backup/src/server/rest.rs

525 lines
17 KiB
Rust
Raw Normal View History

server/rest.rs: fake login cookie
2019-01-23 11:49:10 +00:00
use crate::tools;
cleanup module names
2018-11-15 16:07:10 +00:00
use crate::api::schema::*;
use crate::api::router::*;
use crate::api::config::*;
server/rest.rs: verify auth cookie
2019-01-31 11:22:00 +00:00
use crate::auth_helpers::*;
move rpc environment implementation to separate files
2019-01-26 14:08:02 +00:00
use super::environment::RestEnvironment;
add output formatter
2018-12-05 11:42:25 +00:00
use super::formatter::*;
move ApiConfig into extra file
2018-11-15 09:14:08 +00:00
set content type for static file download
2018-12-02 10:00:52 +00:00
use std::path::{Path, PathBuf};
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
use std::sync::Arc;
handle uri parameters correctly
2018-11-16 08:15:33 +00:00
use std::collections::HashMap;
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
use failure::*;
remove www/pbs-index.html.tt, hardcode into rust for now
2018-12-01 12:37:49 +00:00
use serde_json::{json, Value};
handle uri parameters correctly
2018-11-16 08:15:33 +00:00
use url::form_urlencoded;
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
use futures::future::{self, Either};
//use tokio::prelude::*;
//use tokio::timer::Delay;
use tokio::fs::File;
//use bytes::{BytesMut, BufMut};
//use hyper::body::Payload;
use hyper::http::request::Parts;
avoid macros
2018-11-15 09:57:52 +00:00
use hyper::{Body, Request, Response, StatusCode};
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
use hyper::service::{Service, NewService};
use hyper::rt::{Future, Stream};
use hyper::header;
implement relead_timezone flag
2019-02-01 08:54:56 +00:00
extern "C" { fn tzset(); }
reorder content
2018-11-15 09:18:01 +00:00
pub struct RestServer {
pub api_config: Arc<ApiConfig>,
}
impl RestServer {
pub fn new(api_config: ApiConfig) -> Self {
Self { api_config: Arc::new(api_config) }
}
}
impl NewService for RestServer
{
type ReqBody = Body;
type ResBody = Body;
type Error = hyper::Error;
type InitError = hyper::Error;
type Service = ApiService;
type Future = Box<Future<Item = Self::Service, Error = Self::InitError> + Send>;
fn new_service(&self) -> Self::Future {
Box::new(future::ok(ApiService { api_config: self.api_config.clone() }))
}
}
pub struct ApiService {
pub api_config: Arc<ApiConfig>,
}
src/server/rest.rs: log failed requests
2019-02-14 12:07:34 +00:00
impl ApiService {
fn log_response(path: &str, resp: &Response<Body>) {
avoid double logging of proxied requests
2019-02-14 12:28:41 +00:00
server/rest.rs: use a protocol extension to avoid double log Instead of modifying the response header itself.
2019-02-14 15:04:24 +00:00
if resp.extensions().get::<NoLogExtension>().is_some() { return; };
avoid double logging of proxied requests
2019-02-14 12:28:41 +00:00
src/server/rest.rs: log failed requests
2019-02-14 12:07:34 +00:00
let status = resp.status();
avoid double logging of proxied requests
2019-02-14 12:28:41 +00:00
src/server/rest.rs: log failed requests
2019-02-14 12:07:34 +00:00
if !status.is_success() {
let reason = status.canonical_reason().unwrap_or("unknown reason");
let client = "unknown"; // fixme: howto get peer_addr ?
let message = "request failed";
log::error!("{}: {} {}: [client {}] {}", path, status.as_str(), reason, client, message);
}
}
}
reorder content
2018-11-15 09:18:01 +00:00
impl Service for ApiService {
type ReqBody = Body;
type ResBody = Body;
type Error = hyper::Error;
type Future = Box<Future<Item = Response<Body>, Error = Self::Error> + Send>;
fn call(&mut self, req: Request<Self::ReqBody>) -> Self::Future {
src/server/rest.rs: log failed requests
2019-02-14 12:07:34 +00:00
let path = req.uri().path().to_owned();
Box::new(handle_request(self.api_config.clone(), req).then(move |result| {
reorder content
2018-11-15 09:18:01 +00:00
match result {
src/server/rest.rs: log failed requests
2019-02-14 12:07:34 +00:00
Ok(res) => {
Self::log_response(&path, &res);
Ok::<_, hyper::Error>(res)
}
reorder content
2018-11-15 09:18:01 +00:00
Err(err) => {
src/client/http_client.rs: try to login use an environment var to store passphrase (PBS_PASSWORD)
2019-02-13 13:31:43 +00:00
if let Some(apierr) = err.downcast_ref::<HttpError>() {
reorder content
2018-11-15 09:18:01 +00:00
let mut resp = Response::new(Body::from(apierr.message.clone()));
*resp.status_mut() = apierr.code;
src/server/rest.rs: log failed requests
2019-02-14 12:07:34 +00:00
Self::log_response(&path, &resp);
reorder content
2018-11-15 09:18:01 +00:00
Ok(resp)
} else {
let mut resp = Response::new(Body::from(err.to_string()));
*resp.status_mut() = StatusCode::BAD_REQUEST;
src/server/rest.rs: log failed requests
2019-02-14 12:07:34 +00:00
Self::log_response(&path, &resp);
reorder content
2018-11-15 09:18:01 +00:00
Ok(resp)
}
}
}
}))
}
}
remove unneeded lifetime annotations
2018-11-15 09:25:59 +00:00
fn get_request_parameters_async(
info: &'static ApiMethod,
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
parts: Parts,
req_body: Body,
handle uri parameters correctly
2018-11-16 08:15:33 +00:00
uri_param: HashMap<String, String>,
remove unneeded lifetime annotations
2018-11-15 09:25:59 +00:00
) -> Box<Future<Item = Value, Error = failure::Error> + Send>
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
{
let resp = req_body
rename ApiError into HttpError
2018-11-15 09:42:01 +00:00
.map_err(|err| http_err!(BAD_REQUEST, format!("Promlems reading request body: {}", err)))
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
.fold(Vec::new(), |mut acc, chunk| {
if acc.len() + chunk.len() < 64*1024 { //fimxe: max request body size?
acc.extend_from_slice(&*chunk);
Ok(acc)
}
rename ApiError into HttpError
2018-11-15 09:42:01 +00:00
else { Err(http_err!(BAD_REQUEST, format!("Request body too large"))) }
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
})
.and_then(move |body| {
rest: rename utf-8-checked 'bytes' to 'utf8' Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com>
2019-01-08 13:22:43 +00:00
let utf8 = std::str::from_utf8(&body)?;
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
handle uri parameters correctly
2018-11-16 08:15:33 +00:00
let mut param_list: Vec<(String, String)> = vec![];
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
rest: rename utf-8-checked 'bytes' to 'utf8' Signed-off-by: Wolfgang Bumiller <w.bumiller@proxmox.com>
2019-01-08 13:22:43 +00:00
if utf8.len() > 0 {
for (k, v) in form_urlencoded::parse(utf8.as_bytes()).into_owned() {
handle uri parameters correctly
2018-11-16 08:15:33 +00:00
param_list.push((k, v));
}
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
}
if let Some(query_str) = parts.uri.query() {
handle uri parameters correctly
2018-11-16 08:15:33 +00:00
for (k, v) in form_urlencoded::parse(query_str.as_bytes()).into_owned() {
add output formatter
2018-12-05 11:42:25 +00:00
if k == "_dc" { continue; } // skip extjs "disable cache" parameter
handle uri parameters correctly
2018-11-16 08:15:33 +00:00
param_list.push((k, v));
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
}
}
handle uri parameters correctly
2018-11-16 08:15:33 +00:00
for (k, v) in uri_param {
param_list.push((k.clone(), v.clone()));
}
let params = parse_parameter_strings(&param_list, &info.parameters, true)?;
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
Ok(params)
});
Box::new(resp)
}
server/rest.rs: use a protocol extension to avoid double log Instead of modifying the response header itself.
2019-02-14 15:04:24 +00:00
struct NoLogExtension();
server/rest.rs: simplify proxy code Only pass neccessary parameters.
2019-01-28 17:22:16 +00:00
fn proxy_protected_request(
implement relead_timezone flag
2019-02-01 08:54:56 +00:00
info: &'static ApiMethod,
server/rest.rs: implement proxy_sync_api_request
2019-01-28 17:06:42 +00:00
mut parts: Parts,
server/rest.rs: add proxy_sync_api_request() dummy
2019-01-28 16:30:39 +00:00
req_body: Body,
) -> BoxFut
{
server/rest.rs: implement proxy_sync_api_request
2019-01-28 17:06:42 +00:00
let mut uri_parts = parts.uri.clone().into_parts();
uri_parts.scheme = Some(http::uri::Scheme::HTTP);
uri_parts.authority = Some(http::uri::Authority::from_static("127.0.0.1:82"));
let new_uri = http::Uri::from_parts(uri_parts).unwrap();
parts.uri = new_uri;
let request = Request::from_parts(parts, req_body);
let resp = hyper::client::Client::new()
.request(request)
avoid double logging of proxied requests
2019-02-14 12:28:41 +00:00
.map_err(|e| Error::from(e))
.map(|mut resp| {
server/rest.rs: use a protocol extension to avoid double log Instead of modifying the response header itself.
2019-02-14 15:04:24 +00:00
resp.extensions_mut().insert(NoLogExtension);
avoid double logging of proxied requests
2019-02-14 12:28:41 +00:00
resp
});
server/rest.rs: implement proxy_sync_api_request
2019-01-28 17:06:42 +00:00
implement relead_timezone flag
2019-02-01 08:54:56 +00:00
let resp = if info.reload_timezone {
Either::A(resp.then(|resp| {unsafe { tzset() }; resp }))
} else {
Either::B(resp)
};
server/rest.rs: implement proxy_sync_api_request
2019-01-28 17:06:42 +00:00
return Box::new(resp);
server/rest.rs: add proxy_sync_api_request() dummy
2019-01-28 16:30:39 +00:00
}
remove unneeded lifetime annotations
2018-11-15 09:25:59 +00:00
fn handle_sync_api_request(
also pass rpcenv to async handlers
2019-01-27 09:18:52 +00:00
mut rpcenv: RestEnvironment,
remove unneeded lifetime annotations
2018-11-15 09:25:59 +00:00
info: &'static ApiMethod,
add output formatter
2018-12-05 11:42:25 +00:00
formatter: &'static OutputFormatter,
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
parts: Parts,
req_body: Body,
handle uri parameters correctly
2018-11-16 08:15:33 +00:00
uri_param: HashMap<String, String>,
remove unneeded lifetime annotations
2018-11-15 09:25:59 +00:00
) -> BoxFut
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
{
handle uri parameters correctly
2018-11-16 08:15:33 +00:00
let params = get_request_parameters_async(info, parts, req_body, uri_param);
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
delay unauthorized request (rate limit)
2019-01-31 13:34:21 +00:00
let delay_unauth_time = std::time::Instant::now() + std::time::Duration::from_millis(3000);
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
let resp = params
.and_then(move |params| {
delay unauthorized request (rate limit)
2019-01-31 13:34:21 +00:00
let mut delay = false;
api: pass RpcEnvirnment to api handlers
2019-01-26 13:50:37 +00:00
let resp = match (info.handler)(params, info, &mut rpcenv) {
Ok(data) => (formatter.format_result)(data, &rpcenv),
delay unauthorized request (rate limit)
2019-01-31 13:34:21 +00:00
Err(err) => {
if let Some(httperr) = err.downcast_ref::<HttpError>() {
if httperr.code == StatusCode::UNAUTHORIZED { delay = true; }
}
(formatter.format_error)(err)
}
api: pass RpcEnvirnment to api handlers
2019-01-26 13:50:37 +00:00
};
delay unauthorized request (rate limit)
2019-01-31 13:34:21 +00:00
implement relead_timezone flag
2019-02-01 08:54:56 +00:00
if info.reload_timezone {
unsafe { tzset() };
}
delay unauthorized request (rate limit)
2019-01-31 13:34:21 +00:00
if delay {
let delayed_response = tokio::timer::Delay::new(delay_unauth_time)
.map_err(|err| http_err!(INTERNAL_SERVER_ERROR, format!("tokio timer delay error: {}", err)))
.and_then(|_| Ok(resp));
Either::A(delayed_response)
} else {
Either::B(future::ok(resp))
}
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
});
Box::new(resp)
}
api/router.rs: rename ApiUploadMethod to ApiAsyncMethod We can use this for uploads and downloads ...
2019-01-19 15:42:43 +00:00
fn handle_async_api_request(
also pass rpcenv to async handlers
2019-01-27 09:18:52 +00:00
mut rpcenv: RestEnvironment,
api/router.rs: rename ApiUploadMethod to ApiAsyncMethod We can use this for uploads and downloads ...
2019-01-19 15:42:43 +00:00
info: &'static ApiAsyncMethod,
server/rest.rs: correctly pass query/url parameters
2019-01-16 12:58:36 +00:00
formatter: &'static OutputFormatter,
parts: Parts,
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads.
2019-01-14 11:26:04 +00:00
req_body: Body,
uri_param: HashMap<String, String>,
) -> BoxFut
{
// fixme: convert parameters to Json
let mut param_list: Vec<(String, String)> = vec![];
server/rest.rs: correctly pass query/url parameters
2019-01-16 12:58:36 +00:00
if let Some(query_str) = parts.uri.query() {
for (k, v) in form_urlencoded::parse(query_str.as_bytes()).into_owned() {
if k == "_dc" { continue; } // skip extjs "disable cache" parameter
param_list.push((k, v));
}
}
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads.
2019-01-14 11:26:04 +00:00
for (k, v) in uri_param {
param_list.push((k.clone(), v.clone()));
}
let params = match parse_parameter_strings(&param_list, &info.parameters, true) {
Ok(v) => v,
Err(err) => {
api: pass RpcEnvirnment to api handlers
2019-01-26 13:50:37 +00:00
let resp = (formatter.format_error)(Error::from(err));
server/rest.rs: correctly pass query/url parameters
2019-01-16 12:58:36 +00:00
return Box::new(future::ok(resp));
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads.
2019-01-14 11:26:04 +00:00
}
};
also pass rpcenv to async handlers
2019-01-27 09:18:52 +00:00
match (info.handler)(parts, req_body, params, info, &mut rpcenv) {
api/router.rs: return Result in upload handler
2019-01-17 11:03:38 +00:00
Ok(future) => future,
Err(err) => {
api: pass RpcEnvirnment to api handlers
2019-01-26 13:50:37 +00:00
let resp = (formatter.format_error)(Error::from(err));
api/router.rs: return Result in upload handler
2019-01-17 11:03:38 +00:00
Box::new(future::ok(resp))
}
}
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads.
2019-01-14 11:26:04 +00:00
}
remove www/pbs-index.html.tt, hardcode into rust for now
2018-12-01 12:37:49 +00:00
fn get_index() -> BoxFut {
server/rest.rs: fake login cookie
2019-01-23 11:49:10 +00:00
let nodename = tools::nodename();
api2/access.rs: add ticket api
2019-01-30 14:14:20 +00:00
let username = ""; // fixme: implement real auth
let token = "";
remove www/pbs-index.html.tt, hardcode into rust for now
2018-12-01 12:37:49 +00:00
let setup = json!({
"Setup": { "auth_cookie_name": "PBSAuthCookie" },
"NodeName": nodename,
"UserName": username,
server/rest.rs: fake login cookie
2019-01-23 11:49:10 +00:00
"CSRFPreventionToken": token,
remove www/pbs-index.html.tt, hardcode into rust for now
2018-12-01 12:37:49 +00:00
});
let index = format!(r###"
<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no">
<title>Proxmox Backup Server</title>
fix file download, listen to 0.0.0.0
2018-12-01 14:21:25 +00:00
<link rel="icon" sizes="128x128" href="/images/logo-128.png" />
remove www/pbs-index.html.tt, hardcode into rust for now
2018-12-01 12:37:49 +00:00
<link rel="apple-touch-icon" sizes="128x128" href="/pve2/images/logo-128.png" />
fix file download, listen to 0.0.0.0
2018-12-01 14:21:25 +00:00
<link rel="stylesheet" type="text/css" href="/extjs/theme-crisp/resources/theme-crisp-all.css" />
<link rel="stylesheet" type="text/css" href="/extjs/crisp/resources/charts-all.css" />
remove www/pbs-index.html.tt, hardcode into rust for now
2018-12-01 12:37:49 +00:00
<link rel="stylesheet" type="text/css" href="/fontawesome/css/font-awesome.css" />
<script type='text/javascript'> function gettext(buf) {{ return buf; }} </script>
fix file download, listen to 0.0.0.0
2018-12-01 14:21:25 +00:00
<script type="text/javascript" src="/extjs/ext-all-debug.js"></script>
<script type="text/javascript" src="/extjs/charts-debug.js"></script>
remove www/pbs-index.html.tt, hardcode into rust for now
2018-12-01 12:37:49 +00:00
<script type="text/javascript">
Proxmox = {};
</script>
fix file download, listen to 0.0.0.0
2018-12-01 14:21:25 +00:00
<script type="text/javascript" src="/widgettoolkit/proxmoxlib.js"></script>
<script type="text/javascript" src="/extjs/locale/locale-en.js"></script>
remove www/pbs-index.html.tt, hardcode into rust for now
2018-12-01 12:37:49 +00:00
<script type="text/javascript">
Ext.History.fieldid = 'x-history-field';
</script>
start the GUI
2018-12-04 16:53:10 +00:00
<script type="text/javascript" src="/js/proxmox-backup-gui.js"></script>
remove www/pbs-index.html.tt, hardcode into rust for now
2018-12-01 12:37:49 +00:00
</head>
<body>
<!-- Fields required for history management -->
<form id="history-form" class="x-hidden">
<input type="hidden" id="x-history-field"/>
</form>
</body>
</html>
"###, setup.to_string());
server/rest.rs: fake login cookie
2019-01-23 11:49:10 +00:00
let resp = Response::builder()
.status(StatusCode::OK)
.header(header::CONTENT_TYPE, "text/html")
.body(index.into())
.unwrap();
Box::new(future::ok(resp))
remove www/pbs-index.html.tt, hardcode into rust for now
2018-12-01 12:37:49 +00:00
}
set content type for static file download
2018-12-02 10:00:52 +00:00
fn extension_to_content_type(filename: &Path) -> (&'static str, bool) {
if let Some(ext) = filename.extension().and_then(|osstr| osstr.to_str()) {
return match ext {
"css" => ("text/css", false),
"html" => ("text/html", false),
"js" => ("application/javascript", false),
"json" => ("application/json", false),
"map" => ("application/json", false),
"png" => ("image/png", true),
"ico" => ("image/x-icon", true),
"gif" => ("image/gif", true),
"svg" => ("image/svg+xml", false),
"jar" => ("application/java-archive", true),
"woff" => ("application/font-woff", true),
"woff2" => ("application/font-woff2", true),
"ttf" => ("application/font-snft", true),
"pdf" => ("application/pdf", true),
"epub" => ("application/epub+zip", true),
"mp3" => ("audio/mpeg", true),
"oga" => ("audio/ogg", true),
"tgz" => ("application/x-compressed-tar", true),
_ => ("application/octet-stream", false),
};
}
("application/octet-stream", false)
}
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
fn simple_static_file_download(filename: PathBuf) -> BoxFut {
set content type for static file download
2018-12-02 10:00:52 +00:00
let (content_type, _nocomp) = extension_to_content_type(&filename);
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
Box::new(File::open(filename)
rename ApiError into HttpError
2018-11-15 09:42:01 +00:00
.map_err(|err| http_err!(BAD_REQUEST, format!("File open failed: {}", err)))
set content type for static file download
2018-12-02 10:00:52 +00:00
.and_then(move |file| {
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
let buf: Vec<u8> = Vec::new();
tokio::io::read_to_end(file, buf)
rename ApiError into HttpError
2018-11-15 09:42:01 +00:00
.map_err(|err| http_err!(BAD_REQUEST, format!("File read failed: {}", err)))
set content type for static file download
2018-12-02 10:00:52 +00:00
.and_then(move |data| {
let mut response = Response::new(data.1.into());
response.headers_mut().insert(
header::CONTENT_TYPE,
header::HeaderValue::from_static(content_type));
Ok(response)
})
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
}))
}
fn chuncked_static_file_download(filename: PathBuf) -> BoxFut {
set content type for static file download
2018-12-02 10:00:52 +00:00
let (content_type, _nocomp) = extension_to_content_type(&filename);
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
Box::new(File::open(filename)
rename ApiError into HttpError
2018-11-15 09:42:01 +00:00
.map_err(|err| http_err!(BAD_REQUEST, format!("File open failed: {}", err)))
set content type for static file download
2018-12-02 10:00:52 +00:00
.and_then(move |file| {
remove crate tokio-codec (seems to be part of tokio now)
2019-01-20 13:28:06 +00:00
let payload = tokio::codec::FramedRead::new(file, tokio::codec::BytesCodec::new()).
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
map(|bytes| {
//sigh - howto avoid copy here? or the whole map() ??
hyper::Chunk::from(bytes.to_vec())
});
let body = Body::wrap_stream(payload);
set content type for static file download
2018-12-02 10:00:52 +00:00
// fixme: set other headers ?
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
Ok(Response::builder()
.status(StatusCode::OK)
set content type for static file download
2018-12-02 10:00:52 +00:00
.header(header::CONTENT_TYPE, content_type)
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
.body(body)
.unwrap())
}))
}
fn handle_static_file_download(filename: PathBuf) -> BoxFut {
let response = tokio::fs::metadata(filename.clone())
rename ApiError into HttpError
2018-11-15 09:42:01 +00:00
.map_err(|err| http_err!(BAD_REQUEST, format!("File access problems: {}", err)))
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
.and_then(|metadata| {
if metadata.len() < 1024*32 {
Either::A(simple_static_file_download(filename))
} else {
Either::B(chuncked_static_file_download(filename))
}
});
return Box::new(response);
}
pub fn handle_request(api: Arc<ApiConfig>, req: Request<Body>) -> BoxFut {
let (parts, body) = req.into_parts();
let method = parts.method.clone();
let path = parts.uri.path();
// normalize path
// do not allow ".", "..", or hidden files ".XXXX"
// also remove empty path components
let items = path.split('/');
let mut path = String::new();
let mut components = vec![];
for name in items {
if name.is_empty() { continue; }
if name.starts_with(".") {
avoid macros
2018-11-15 09:57:52 +00:00
return Box::new(future::err(http_err!(BAD_REQUEST, "Path contains illegal components.".to_string())));
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
}
path.push('/');
path.push_str(name);
components.push(name);
}
let comp_len = components.len();
println!("REQUEST {} {}", method, path);
println!("COMPO {:?}", components);
server/rest.rs: add proxy_sync_api_request() dummy
2019-01-28 16:30:39 +00:00
let env_type = api.env_type();
let mut rpcenv = RestEnvironment::new(env_type);
also pass rpcenv to async handlers
2019-01-27 09:18:52 +00:00
server/rest.rs: verify auth cookie
2019-01-31 11:22:00 +00:00
let delay_unauth_time = std::time::Instant::now() + std::time::Duration::from_millis(3000);
if let Some(raw_cookie) = parts.headers.get("COOKIE") {
if let Ok(cookie) = raw_cookie.to_str() {
if let Some(ticket) = tools::extract_auth_cookie(cookie, "PBSAuthCookie") {
if let Ok((_, Some(username))) = tools::ticket::verify_rsa_ticket(
public_auth_key(), "PBS", &ticket, None, -300, 3600*2) {
rpcenv.set_user(Some(username));
}
}
}
}
rename api3 back to api2 There is no real need to change the path, so using api2 we can reuse all helpers (like tools from proxmox widget toolkit).
2019-01-22 11:10:38 +00:00
if comp_len >= 1 && components[0] == "api2" {
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
println!("GOT API REQUEST");
if comp_len >= 2 {
let format = components[1];
add output formatter
2018-12-05 11:42:25 +00:00
let formatter = match format {
"json" => &JSON_FORMATTER,
"extjs" => &EXTJS_FORMATTER,
_ => {
return Box::new(future::err(http_err!(BAD_REQUEST, format!("Unsupported output format '{}'.", format))));
}
};
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
handle uri parameters correctly
2018-11-16 08:15:33 +00:00
let mut uri_param = HashMap::new();
server/rest.rs: verify auth cookie
2019-01-31 11:22:00 +00:00
if comp_len == 4 && components[2] == "access" && components[3] == "ticket" {
// explicitly allow those calls without auth
} else {
if let Some(_username) = rpcenv.get_user() {
// fixme: check permissions
} else {
// always delay unauthorized calls by 3 seconds (from start of request)
let resp = (formatter.format_error)(http_err!(UNAUTHORIZED, "permission check failed.".into()));
let delayed_response = tokio::timer::Delay::new(delay_unauth_time)
.map_err(|err| http_err!(INTERNAL_SERVER_ERROR, format!("tokio timer delay error: {}", err)))
.and_then(|_| Ok(resp));
return Box::new(delayed_response);
}
}
RpcEnvironment: implement set_user() and get_user()
2019-01-27 09:42:45 +00:00
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads.
2019-01-14 11:26:04 +00:00
match api.find_method(&components[2..], method, &mut uri_param) {
MethodDefinition::None => {}
MethodDefinition::Simple(api_method) => {
server/rest.rs: add proxy_sync_api_request() dummy
2019-01-28 16:30:39 +00:00
if api_method.protected && env_type == RpcEnvironmentType::PUBLIC {
implement relead_timezone flag
2019-02-01 08:54:56 +00:00
return proxy_protected_request(api_method, parts, body);
server/rest.rs: add proxy_sync_api_request() dummy
2019-01-28 16:30:39 +00:00
} else {
return handle_sync_api_request(rpcenv, api_method, formatter, parts, body, uri_param);
}
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads.
2019-01-14 11:26:04 +00:00
}
api/router.rs: rename ApiUploadMethod to ApiAsyncMethod We can use this for uploads and downloads ...
2019-01-19 15:42:43 +00:00
MethodDefinition::Async(async_method) => {
also pass rpcenv to async handlers
2019-01-27 09:18:52 +00:00
return handle_async_api_request(rpcenv, async_method, formatter, parts, body, uri_param);
api/router.rs: allow different types of api methods Added a prototype for file/backup uploads.
2019-01-14 11:26:04 +00:00
}
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
}
}
} else {
// not Auth for accessing files!
remove www/pbs-index.html.tt, hardcode into rust for now
2018-12-01 12:37:49 +00:00
if comp_len == 0 {
return get_index();
} else {
let filename = api.find_alias(&components);
return handle_static_file_download(filename);
}
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
}
avoid macros
2018-11-15 09:57:52 +00:00
Box::new(future::err(http_err!(NOT_FOUND, "Path not found.".to_string())))
move server code to api_server.rs, implement Service and NewService
2018-11-15 07:18:48 +00:00
}