upgrade dependencies and time handling

This commit is contained in:
neri 2022-09-30 14:38:33 +02:00
parent 4ea8797149
commit 1527445857
5 changed files with 25 additions and 30 deletions

View File

@ -1,6 +1,6 @@
[package]
name = "datatrash"
version = "1.1.5"
version = "1.1.6"
authors = ["neri"]
edition = "2021"

View File

@ -1,6 +1,7 @@
use std::env;
use std::path::PathBuf;
use time::ext::NumericalDuration;
use time::Duration;
use tokio::fs;
@ -28,8 +29,8 @@ pub async fn get_config() -> Config {
let max_file_size = env::var("UPLOAD_MAX_BYTES")
.ok()
.and_then(|variable| variable.parse().ok())
.unwrap_or(8 * 1024 * 1024);
let max_file_size = (max_file_size != 0).then(|| max_file_size);
.or(Some(8 * 1024 * 1024))
.filter(|&max_file_size| max_file_size != 0);
let static_dir =
PathBuf::from(env::var("STATIC_DIR").unwrap_or_else(|_| "./static".to_owned()));
@ -73,8 +74,8 @@ fn get_no_auth_limits() -> Option<NoAuthLimits> {
(Some(auth_password), Some(max_time), Some(large_file_max_time), Some(large_file_size)) => {
Some(NoAuthLimits {
auth_password,
max_time: Duration::seconds(max_time as i64),
large_file_max_time: Duration::seconds(large_file_max_time as i64),
max_time: (max_time as i64).seconds(),
large_file_max_time: (large_file_max_time as i64).seconds(),
large_file_size,
})
}

View File

@ -1,5 +1,6 @@
use sqlx::postgres::{PgPool, PgPoolOptions};
use std::env;
use time::ext::NumericalStdDuration;
pub async fn setup_db() -> PgPool {
let conn_url = &get_db_url();
@ -7,7 +8,7 @@ pub async fn setup_db() -> PgPool {
let pool = PgPoolOptions::new()
.max_connections(5)
.acquire_timeout(std::time::Duration::from_secs(5))
.acquire_timeout(5.std_seconds())
.connect(conn_url)
.await
.expect("could not create db pool");

View File

@ -7,8 +7,8 @@ use std::path::Path;
use time::{Duration, OffsetDateTime};
use tokio::{fs::File, io::AsyncWriteExt};
const MAX_UPLOAD_SECONDS: i64 = 31 * 24 * 60 * 60;
const DEFAULT_UPLOAD_SECONDS: u32 = 30 * 60;
const MAX_UPLOAD_DURATION: Duration = Duration::days(31);
const DEFAULT_UPLOAD_DURATION: Duration = Duration::minutes(30);
pub(crate) struct UploadConfig {
pub original_name: Option<String>,
@ -24,7 +24,7 @@ pub(crate) async fn parse_multipart(
) -> Result<UploadConfig, error::Error> {
let mut original_name: Option<String> = None;
let mut content_type: Option<Mime> = None;
let mut keep_for: Option<String> = None;
let mut keep_for_seconds: Option<String> = None;
let mut delete_on_download = false;
let mut password = None;
let mut size = 0;
@ -34,7 +34,7 @@ pub(crate) async fn parse_multipart(
let name = name.as_str();
match name {
"keep_for" => {
keep_for = Some(parse_string(name, field).await?);
keep_for_seconds = Some(parse_string(name, field).await?);
}
"file" => {
let (mime, uploaded_name) = get_file_metadata(&field);
@ -64,13 +64,13 @@ pub(crate) async fn parse_multipart(
let content_type =
content_type.ok_or_else(|| error::ErrorBadRequest("no content type found"))?;
let keep_for: u32 = keep_for
let keep_for = keep_for_seconds
.map(|k| k.parse())
.transpose()
.map_err(|e| error::ErrorBadRequest(format!("field keep_for is not a number: {}", e)))?
.unwrap_or(DEFAULT_UPLOAD_SECONDS);
let valid_duration = Duration::seconds(keep_for.into());
let valid_till = OffsetDateTime::now_utc() + valid_duration;
.map(Duration::seconds)
.unwrap_or(DEFAULT_UPLOAD_DURATION);
let valid_till = OffsetDateTime::now_utc() + keep_for;
let upload_config = UploadConfig {
original_name,
@ -79,7 +79,7 @@ pub(crate) async fn parse_multipart(
delete_on_download,
};
check_requirements(&upload_config, size, password, &valid_duration, config)?;
check_requirements(&upload_config, size, password, &keep_for, config)?;
Ok(upload_config)
}
@ -88,7 +88,7 @@ fn check_requirements(
upload_config: &UploadConfig,
size: u64,
password: Option<String>,
valid_duration: &Duration,
keep_for: &Duration,
config: &config::Config,
) -> Result<(), error::Error> {
if let Some(original_name) = upload_config.original_name.as_ref() {
@ -97,17 +97,16 @@ fn check_requirements(
}
}
let valid_seconds = valid_duration.whole_seconds();
if valid_seconds > MAX_UPLOAD_SECONDS {
if *keep_for > MAX_UPLOAD_DURATION {
return Err(error::ErrorBadRequest(format!(
"maximum allowed validity is {} seconds, but you specified {} seconds",
MAX_UPLOAD_SECONDS, valid_seconds
"maximum allowed validity is {}, but you specified {}",
MAX_UPLOAD_DURATION, keep_for
)));
}
if let Some(no_auth_limits) = &config.no_auth_limits {
let requires_auth = valid_seconds > no_auth_limits.max_time.whole_seconds()
|| valid_seconds > no_auth_limits.large_file_max_time.whole_seconds()
let requires_auth = *keep_for > no_auth_limits.max_time
|| *keep_for > no_auth_limits.large_file_max_time
&& size > no_auth_limits.large_file_size;
// hIGh sECUriTy paSsWoRD CHEck
if requires_auth && password.as_ref() != Some(&no_auth_limits.auth_password) {

View File

@ -14,11 +14,6 @@ impl KeyExtractor for ForwardedPeerIpKeyExtractor {
type Key = IpAddr;
type KeyExtractionError = &'static str;
#[cfg(feature = "log")]
fn name(&self) -> &'static str {
"Forwarded peer IP"
}
fn extract(&self, req: &ServiceRequest) -> Result<Self::Key, Self::KeyExtractionError> {
let forwarded_for = req.headers().get("x-forwarded-for");
if !self.proxied && forwarded_for.is_some() {
@ -44,8 +39,7 @@ impl KeyExtractor for ForwardedPeerIpKeyExtractor {
)
}
#[cfg(feature = "log")]
fn key_name(&self, key: &Self::Key) -> Option<String> {
Some(key.to_string())
fn response_error(&self, err: Self::KeyExtractionError) -> actix_web::Error {
actix_web::error::ErrorUnauthorized(err.to_string())
}
}