Struct CGIDir 

pub struct CGIDir { /* private fields */ }

Custom handler to execute CGIScripts

This handler will execute any script within the directory provided. See examples/cgi.rs for a full usage example

Implementations

impl CGIDir

pub fn new(path: impl AsRef<Path>) -> Self

Generate a CGI script from the associated path

build().mount("/", CGIDir::new("examples"))

pub fn clear_file_types(self) -> Self

Clear file type associations, and disables directly running executables

let rocket = build().mount("/", CGIDir::new("test").clear_file_types());
let client = Client::tracked(rocket).unwrap();
let res = client.get("/simple.sh").dispatch();
assert_eq!(res.status(), Status::InternalServerError);
// Since the file could not be executed, a 500 error is returned

pub fn set_file_type( self, extension: impl Into<Cow<'static, str>>, executable: impl Into<Cow<'static, Path>>, ) -> Self

Add a file type association for executing a file. Overrides an existing file type association if one exists.

let rocket = build().mount("/",
    CGIDir::new("test")
        .clear_file_types()// Clear file types
        .set_file_type("sh", Path::new("sh"))// manually insert `sh`
    );
let client = Client::tracked(rocket).unwrap();
let res = client.get("/simple.sh").dispatch();
assert_eq!(res.status(), Status::Ok);

pub fn only_perl(self) -> Self

Only allow executing perl scripts. Disables all filetypes except .pl

let rocket = build().mount("/", CGIDir::new("test").only_perl());
let client = Client::tracked(rocket).unwrap();
let res = client.get("/simple.pl").dispatch();
assert_eq!(res.status(), Status::Ok);
let res = client.get("/simple.sh").dispatch();
assert_eq!(res.status(), Status::InternalServerError);

pub fn only_python(self) -> Self

Only allow executing python scripts. Disables all filetypes except .py

let rocket = build().mount("/", CGIDir::new("test").only_python().detect_python3());
let client = Client::tracked(rocket).unwrap();
let res = client.get("/simple.py").dispatch();
assert_eq!(res.status(), Status::Ok);
let res = client.get("/simple.sh").dispatch();
assert_eq!(res.status(), Status::InternalServerError);

pub fn detect_python3(self) -> Self

Automatically detect python executables. This should allow either python or python3 to be present on the system

let rocket = build().mount("/", CGIDir::new("test").detect_python3());
let client = Client::tracked(rocket).unwrap();
let res = client.get("/simple.py").dispatch();
assert_eq!(res.status(), Status::Ok);

Panics

If python cannot be found on the current Path. If a version of python not on the path is desired, it is recommended to explicitly set the path e.g. .set_file_type("py", Path::new("/opt/py/bin/python"))

pub fn detect_python2(self) -> Self

Automatically detect python executables. This should allow either python or python2 to be present on the system

let rocket = build().mount("/", CGIDir::new("test").detect_python2());
let client = Client::tracked(rocket).unwrap();
let res = client.get("/simple.py").dispatch();
assert_eq!(res.status(), Status::Ok);

Panics

If python cannot be found on the current Path. If a version of python not on the path is desired, it is recommended to explicitly set the path e.g. .set_file_type("py", Path::new("/opt/py/bin/python"))

pub fn only_sh(self) -> Self

Only allow executing python scripts. Disables all filetypes except .sh

let rocket = build().mount("/", CGIDir::new("test").only_sh());
let client = Client::tracked(rocket).unwrap();
let res = client.get("/simple.sh").dispatch();
assert_eq!(res.status(), Status::Ok);
let res = client.get("/simple.py").dispatch();
assert_eq!(res.status(), Status::InternalServerError);

pub fn shell_interpreter( self, executable: impl Into<Cow<'static, Path>>, ) -> Self

Sets the shell interpreter. Implicitly enables .sh files if they are currently disabled

Default is sh

let rocket = build().mount("/", CGIDir::new("test").shell_interpreter(Path::new("bash")));
let client = Client::tracked(rocket).unwrap();
let res = client.get("/shell.sh").dispatch();
assert_eq!(res.status(), Status::Ok);
assert_eq!(res.into_string().unwrap(), "bash\n");

pub fn add_windows_scripts(self) -> Self

Adds default Windows Shell Script types:

• cmd.exe: .cmd, .bat
• powershell.exe: .ps1
• cscript.exe: .wsf, .vbs, .js

let rocket = build().mount("/", CGIDir::new("test").add_windows_scripts());
let client = Client::tracked(rocket).unwrap();
let res = client.get("/simple.cmd").dispatch();
assert_eq!(res.status(), Status::Ok);

pub fn direct_executables(self, allow: bool) -> Self

Whether to allow directly executable files. This may allow scripts with execute permissions and a shebang (#!) to be executed, on some systems.

Defaults to true

pub fn unencoded_equals(self, allow: bool) -> Self

Whether to pass parameters that contain unencoded =

The CGI spec requires this to be false, which is the default

pub fn dot_files(self, allow: bool) -> Self

Whether to allow serving unix hidden files (files starting with a .)

Defaults to false

let rocket = build().mount("/", CGIDir::new("test").dot_files(false));
let client = Client::tracked(rocket).unwrap();
let res = client.get("/.simple.sh").dispatch();
assert_eq!(res.status(), Status::NotFound);

pub fn hidden_files(self, allow: bool) -> Self

Whether to allow serving hidden files

Defaults to false, only applies to Windows

pub fn setuid_files(self, allow: bool) -> Self

Whether to allow serving files with setuid & setgid bits set

Defaults to false, only has an effect on Unix systems. Note this does not prevent a script from executing a setuid bit binary, but rather only protects against Rocket starting a setuid binary

pub fn serve_get(self, allow: bool) -> Self

Whether to serve GET & HEAD requests

Defaults to true

let rocket = build().mount("/", CGIDir::new("test").serve_get(false));
let client = Client::tracked(rocket).unwrap();
let res = client.get("/.simple.sh").dispatch();
assert_eq!(res.status(), Status::NotFound);

pub fn serve_post(self, allow: bool) -> Self

Whether to serve POST requests

Defaults to true

let rocket = build().mount("/", CGIDir::new("test").serve_post(false));
let client = Client::tracked(rocket).unwrap();
let res = client.post("/.simple.sh").dispatch();
assert_eq!(res.status(), Status::NotFound);

Trait Implementations

impl Clone for CGIDir

fn clone(&self) -> CGIDir

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CGIDir

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Handler for CGIDir

fn handle<'r, 'life0, 'life1, 'async_trait>( &'life0 self, request: &'r Request<'life1>, data: Data<'r>, ) -> Pin<Box<dyn Future<Output = Outcome<'r>> + Send + 'async_trait>>

where Self: 'async_trait, 'r: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Called by Rocket when a Request with its associated Data should be handled by this handler.

impl Into<Vec<Route>> for CGIDir

fn into(self) -> Vec<Route>

Converts this type into the (usually inferred) input type.

impl PartialEq for CGIDir

fn eq(&self, other: &CGIDir) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for CGIDir

impl StructuralPartialEq for CGIDir