.gitignore

@@ -1,3 +1 @@
 /target
-.idea/
-*.DS_Store

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "urouter"
-version = "0.7.0"
+version = "0.5.2"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/ivabus/urouter"
@@ -9,11 +9,9 @@ description = "Small HTTP router"
 
 [dependencies]
 rocket = "0.5.0"
-serde = { version = "1.0.197", features = ["derive"] }
-serde_json = "1.0.114"
+serde = { version = "1.0.193", features = ["derive"] }
+serde_json = "1.0.108"
 url-escape = "0.1.1"
-once_cell = "1.19"
-clap = { version = "4.5.3", features = ["derive"] }
-regex = "1.10.3"
-ureq = { version = "2.9.6", features = ["brotli", "native-certs"] }
-users = "0.11.0"
+smurf = "0.3.0"
+clap = { version = "4.4.11", features = ["derive"] }
+regex = "1.10.2"

README.md

@@ -16,20 +16,18 @@ JSON file with array of sets (or set with one field of arrays of sets with `--al
 
 Each set contains 2 necessary elements and 1 optional.
 
-- `uri` (string) - of URL after host (e.g., `/`, `some/cool/path`, should not start with `/` (only for root))
-- `alias` (set) - set of one field
-  - `url` (string) - redirect to URL with HTTP 303 See Other
-  - `file` (string) - read file from path `--dir/file` where `--dir` is option (default: `.`, see `--help`) and respond with HTTP 200 OK with `content-type: text/plain`
-  - `text` (string) - plain text with HTTP 200 OK with `content-type: text/plain`
-  - `html` (string) - plain text with HTTP 200 OK with `content-type: text/html`
-  - `external` (set) - download (every time) file using `ureq` HTTP library and response with contents of downloaded resource with HTTP 200 OK and extracted `content-type` from response
-    - `url` (string) - URL to download
-    - `headers` (set, optional) - headers to include with request
-- `agent` (set, optional) - set of one necessary field and one optional
-  - `regex` (string) - regular expression to match user-agent HTTP header
-  - `only_matching` (bool, optional, false by default) - if false whole alias will be visible for any user agent, if true only for regex matched
+- Necessary
+  - `uri` (string) - of url after host (e.g., `/`, `some/cool/path`, should not start with `/` (only for root))
+  - `alias` (set) - set of one field
+    - `url` (string) - redirect to url with HTTP 303 See Other
+    - `file` (string) - read file from path `--dir/file` where `--dir` is option (default: `.`, see `--help`) and respond with HTTP 200 OK with `content-type: text/plain`
+    - `text` (string) - plain text HTTP 200 OK with `content-type: text/plain`
+- Optional
+  - `agent` (set) - set of one necessary field and one optional
+    - `regex` (string) - regular expression to match user-agent HTTP header
+    - `only_matching` (bool, optional, false by default) - if false whole alias will be visible for any user agent, if true only for regex matched
 
-#### Set of array of sets (use only for very specific workarounds)
+#### Set of array of sets
 
 ```json
 {
@@ -69,31 +67,12 @@ Each set contains 2 necessary elements and 1 optional.
     "alias": {
       "text": "sometext"
     }
-  },
-  {
-    "uri": "external",
-    "alias": {
-      "external": {
-        "url": "https://somecool.external.link",
-        "headers": {
-          "user-agent": "curl/8.6.0"
-        }
-      }
-    }
   }
 ]
 ```
 
 Agent matching made for `curl https://url | sh` like scripts.
 
-## `alias.json` location
-
-- Passed with `--alias_file`, will look up to this path, if file doesn't exist (or no access to it) will panic
-- If urouter started with privileges (EUID = 0), file would be `/etc/urouter/alias.json`
-- Otherwise if `XDG_CONFIG_HOME` is set, file would be `$XDG_CONFIG_HOME/urouter/alias.json`
-- Otherwise if `$HOME` is set, file would be `$HOME/.config/urouter/alias.json`
-- If not matched any, will panic and exit
-
 ## License
 
 The project is licensed under the terms of the [MIT license](./LICENSE).

alias.json

@@ -17,22 +17,11 @@
   {
     "uri":"text",
     "alias": {
-      "html": "sometext"
+      "text": "sometext"
     },
     "agent": {
       "regex": "^curl/[0-9].[0-9].[0-9]$",
       "only_matching": true
     }
-  },
-  {
-    "uri": "external",
-    "alias": {
-      "external": {
-        "url": "https://iva.bz",
-        "headers": {
-          "user-agent": "curl/8.6.0"
-        }
-      }
-    }
   }
-]
+]

src/main.rs

@@ -1,67 +1,49 @@
-/* SPDX-License-Identifier: MIT */
-
 /*
-Global comments:
-- I'm ok with unwrapping because if unwrap fails Rocket will automatically return
-  500 Internal Server Error
-*/
-
-#![forbid(unsafe_code)]
+ * MIT License
+ *
+ * Copyright (c) 2023 Ivan Bushchik
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
 
 mod structs;
-use structs::*;
 
+use structs::*;
 #[macro_use]
 extern crate rocket;
 
-use std::io::Write;
-use std::sync::Arc;
-use std::{collections::HashMap, path::PathBuf, time::Instant};
+use rocket::http::Status;
+use std::cell::{OnceCell, RefCell};
+use std::collections::HashMap;
+use std::hint::unreachable_unchecked;
+use std::path::PathBuf;
+use std::time::Instant;
 
-use rocket::http::{ContentType, Status};
-use rocket::{
-	figment::Figment,
-	response::{content::RawHtml, content::RawText, Redirect},
-};
+use rocket::response::content::RawText;
+use rocket::response::Redirect;
 
 use clap::Parser;
-use once_cell::sync::Lazy;
 use regex::Regex;
+use rocket::figment::Figment;
 
-static ALIAS: Lazy<Arc<Vec<Alias>>> = Lazy::new(|| {
-	let mut args = Args::parse();
-	if args.alias_file.is_none() {
-		args.alias_file = Some(get_config_file_location());
-	}
-
-	let file = std::fs::File::open(args.alias_file.unwrap()).unwrap();
-	let alias: Vec<Alias> = if args.alias_file_is_set_not_a_list {
-		serde_json::from_reader::<std::fs::File, NixJson>(file).unwrap().alias
-	} else {
-		serde_json::from_reader::<std::fs::File, Vec<Alias>>(file).unwrap()
-	};
-	Arc::new(alias)
-});
-static COMPILED_REGEXES: Lazy<Arc<HashMap<String, Regex>>> = Lazy::new(|| {
-	let compilation_start = Instant::now();
-	let mut regexes_len = 0;
-	// Precompile all regexes
-	let mut compiled_regexes: HashMap<String, Regex> = HashMap::new();
-	for i in &**ALIAS {
-		if let Some(agent) = &i.agent {
-			compiled_regexes.insert(agent.regex.clone(), Regex::new(&agent.regex).unwrap());
-			regexes_len += 1;
-		}
-	}
-	if regexes_len != 0 {
-		println!(
-			"Compiled {} regexes in {} ms",
-			regexes_len,
-			(Instant::now() - compilation_start).as_secs_f64() * 1000.0
-		);
-	}
-	Arc::new(compiled_regexes)
-});
+static mut ALIAS: OnceCell<Vec<Alias>> = OnceCell::new();
+static mut COMPILED_REGEXES: RefCell<Option<HashMap<String, Regex>>> = RefCell::new(None);
 
 fn get_return(alias: &Alias) -> Response {
 	let args = Args::parse();
@@ -70,22 +52,9 @@ fn get_return(alias: &Alias) -> Response {
 		AliasType::Url(url) => Response::Redirect(Box::from(Redirect::to(url.clone()))),
 		AliasType::File(path) => {
 			dir.push(&PathBuf::from(&path));
-			Response::Text(Box::new(RawText(std::fs::read_to_string(&dir).unwrap())))
-		}
-		AliasType::Text(text) => Response::Text(Box::new(RawText(text.clone()))),
-		AliasType::Html(html) => Response::Html(Box::new(RawHtml(html.clone()))),
-		AliasType::External(source) => {
-			let mut request = ureq::get(&source.url);
-			for (header, value) in &source.headers {
-				request = request.set(header, value);
-			}
-			let result = request.call().unwrap();
-			let ct = result.content_type();
-			Response::Custom(Box::new((
-				ContentType::parse_flexible(ct).unwrap(),
-				RawText(result.into_string().unwrap()),
-			)))
+			Response::Text(RawText(smurf::io::read_file_str(&dir).unwrap()))
 		}
+		AliasType::Text(text) => Response::Text(RawText(text.clone())),
 	}
 }
 
@@ -93,22 +62,29 @@ fn get_return(alias: &Alias) -> Response {
 fn get_page(page: &str, user_agent: UserAgent) -> Response {
 	let mut decoded_page = String::new();
 	url_escape::decode_to_string(page, &mut decoded_page);
+	let alias = unsafe { ALIAS.get().unwrap() };
 	let mut pages = Vec::new();
-	for i in &**ALIAS {
+	for i in alias {
 		if i.uri == decoded_page {
 			if let Some(agent) = &i.agent {
-				let regexes = &COMPILED_REGEXES;
-				let re = regexes.get(&agent.regex).unwrap();
+				unsafe {
+					let regexes = COMPILED_REGEXES.get_mut();
+					let re = if let Some(r) = regexes {
+						// Unwrapping safely, guaranteed to be generated during initialization
+						r.get(&agent.regex).unwrap()
+					} else {
+						unreachable_unchecked()
+					};
 
-				if re.is_match(&user_agent.0) {
-					return get_return(i);
-				}
+					if re.is_match(&user_agent.0) {
+						return get_return(i);
+					}
 
-				if let Some(true) = agent.only_matching {
-					continue;
+					if let Some(true) = agent.only_matching {
+						continue;
+					}
 				}
 			}
-
 			pages.push(i);
 		}
 	}
@@ -124,31 +100,37 @@ async fn index(user_agent: UserAgent) -> Response {
 	get_page("/", user_agent)
 }
 
-fn get_config_file_location() -> PathBuf {
-	if users::get_effective_uid() == 0 {
-		return "/etc/urouter/alias.json".parse().unwrap();
-	}
-
-	if let Ok(config_home) = std::env::var("XDG_CONFIG_HOME") {
-		return format!("{}/urouter/alias.json", config_home).parse().unwrap();
-	}
-
-	if let Ok(home) = std::env::var("HOME") {
-		return format!("{}/.config/urouter/alias.json", home).parse().unwrap();
-	}
-
-	if !std::path::Path::new("alias.json").exists() {
-		let mut file = std::fs::File::create("alias.json").unwrap();
-		file.write_all(b"[]").unwrap();
-	}
-	"alias.json".parse().unwrap()
-}
-
 #[rocket::main]
 async fn main() -> Result<(), rocket::Error> {
 	let args = Args::parse();
-	let _alias = &**ALIAS;
-	let _regex = &**COMPILED_REGEXES;
+	let file = std::fs::File::open(args.alias_file).unwrap();
+	let alias: Vec<Alias> = if args.alias_file_is_set_not_a_list {
+		serde_json::from_reader::<std::fs::File, NixJson>(file).unwrap().alias
+	} else {
+		serde_json::from_reader::<std::fs::File, Vec<Alias>>(file).unwrap()
+	};
+	unsafe {
+		ALIAS.set(alias).unwrap();
+
+		let compilation_start = Instant::now();
+		let mut regexes_len = 0;
+		// Precompile all regexes
+		let mut compiled_regexes: HashMap<String, Regex> = HashMap::new();
+		for i in ALIAS.get().unwrap() {
+			if let Some(agent) = &i.agent {
+				compiled_regexes.insert(agent.regex.clone(), Regex::new(&agent.regex).unwrap());
+				regexes_len += 1;
+			}
+		}
+		if regexes_len != 0 {
+			println!(
+				"Compiled {} regexes in {} ms",
+				regexes_len,
+				(Instant::now() - compilation_start).as_secs_f64() * 1000.0
+			);
+		}
+		*COMPILED_REGEXES.get_mut() = Some(compiled_regexes);
+	}
 
 	let figment = Figment::from(rocket::Config::default())
 		.merge(("ident", format!("urouter/{}", env!("CARGO_PKG_VERSION"))))

src/structs.rs

@@ -1,21 +1,18 @@
-/* SPDX-License-Identifier: MIT */
-
 use clap::Parser;
-use rocket::http::{ContentType, Status};
+use rocket::http::Status;
 use rocket::request::{FromRequest, Outcome};
-use rocket::response::content::{RawHtml, RawText};
-use rocket::response::{Redirect, Responder};
+use rocket::response::content::RawText;
+use rocket::response::Redirect;
 use rocket::Request;
 use serde::Deserialize;
-use std::collections::HashMap;
 use std::net::IpAddr;
 use std::path::PathBuf;
 
 #[derive(Parser, Debug)]
 #[command(about, author)]
 pub struct Args {
-	#[arg(long)]
-	pub alias_file: Option<PathBuf>,
+	#[arg(long, default_value = "./alias.json")]
+	pub alias_file: PathBuf,
 
 	/// For internal usage
 	#[arg(long, default_value = "false")]
@@ -53,10 +50,6 @@ pub enum AliasType {
 	File(String),
 	#[serde(alias = "text")]
 	Text(String),
-	#[serde(alias = "html")]
-	Html(String),
-	#[serde(alias = "external")]
-	External(External),
 }
 
 #[derive(Deserialize, Clone, Debug)]
@@ -65,20 +58,11 @@ pub struct Agent {
 	pub only_matching: Option<bool>,
 }
 
-#[derive(Deserialize, Clone, Debug)]
-pub struct External {
-	pub url: String,
-	#[serde(default)]
-	pub headers: HashMap<String, String>,
-}
-
 #[derive(Responder)]
 pub enum Response {
-	Text(Box<RawText<String>>),
-	Html(Box<RawHtml<String>>),
+	Text(RawText<String>),
 	Redirect(Box<Redirect>),
 	Status(Status),
-	Custom(Box<(ContentType, RawText<String>)>),
 }
 
 pub struct UserAgent(pub String);