herb/src/main.rs

use std::io::{Write, BufReader, BufRead};
use std::thread;
use std::net::{TcpListener, TcpStream};
use std::fs;
use std::string::{String};
use std::process::Command;
use packeteer::http1::*;
use packeteer::generate_kvheader;

struct Resource {
	contents: String,
	status_code: i32,
	mime: String,
}

fn process_cgi(filename: String) -> String {
	// This is gonna be the boggiest implementation of CGI that anyone
	// has ever seen in the history of the fucking world

	let query;
	let script;

	if filename.contains("?") {
		let vars = filename.to_string().find("?").unwrap();
		let vars1 = vars + 1;
		query = &filename[vars1..];
		script = &filename[..vars];
	} else {
		query = "";
		script = &filename;
	}
	println!("{}", script);

	let output;
	if query != "" {
		output = Command::new(format!("./{}", script))
					.env("GATEWAY_INTERFACE", "CGI/1.1")
					.env("SERVER_SOFTWARE", format!("herb/{}", env!("CARGO_PKG_VERSION")))
					.env("REQUEST_METHOD", "GET")
					.env("QUERY_STRING", query)
					.env("SCRIPT_NAME", script)
					.output()
					.expect("failed to execute process");
	} else {
		output = Command::new(format!("./{}", script))
					.env("GATEWAY_INTERFACE", "CGI/1.1")
					.env("SERVER_SOFTWARE", format!("herb/{}", env!("CARGO_PKG_VERSION")))
					.env("REQUEST_METHOD", "GET")
					.env("SCRIPT_NAME", script)
					.output()
					.expect("failed to execute process");
	}
	let outputd = String::from_utf8_lossy(&output.stdout).to_string();
	return outputd;
}

fn detect_media_type(filename: String) -> String {

	// The Lynx terminal browser made me do this.

	let path = filename.to_string();
	let paths = check_if_path_exists(path);
	let path = filename.to_string();
	let dir = check_if_dir(path);

	if paths == true && dir == false && filename.contains(".") == false {
		return "text/html".to_string();
	} else {
		let ext_index = filename.to_string().find(".").unwrap();
		let test = ext_index + 1;
		let ext = &filename[test..];

		if filename[test..].contains("cgi") { return "text/html".to_string(); }

		match ext {
			"aac" => "audio/aac".to_string(),
			"avi" => "video/x-msvideo".to_string(),
			"bmp" => "image/bmp".to_string(),
			"bz2" => "application/x-bzip2".to_string(),
			"css" => "text/css".to_string(),
			"gz" => "application/gzip".to_string(),
			"gif" => "image/gif".to_string(),
			"png" => "image/png".to_string(),
			"pdf" => "application/pdf".to_string(),
			"jpeg" => "image/jpeg".to_string(),
			"jpg" => "image/jpeg".to_string(),
			"js" => "text/javascript".to_string(),
			"mid" => "audio/midi".to_string(),
			"midi" => "audio/midi".to_string(),
			"mp3" => "audio/mpeg".to_string(),
			"mp4" => "video/mp4".to_string(),
			"mpeg" => "video/mpeg".to_string(),
			"ogg" => "audio/ogg".to_string(),
			"oga" => "audio/ogg".to_string(),
			"ogv" => "video/ogg".to_string(),
			"opus" => "audio/opus".to_string(),
			"txt" => "text/plain".to_string(),
			"html" => "text/html".to_string(),
			"htm" => "text/html".to_string(),
			"cgi" => "text/html".to_string(),
			".error_server_404" => "text/html".to_string(),
			".error_server_501" => "text/html".to_string(),
			_ => "application/octet-stream".to_string(),
		}
	}

}

fn check_if_path_exists(path: String) -> bool {

	// This is probably not the best way of checking if a path
	// exists but I don't care :)

	let file = fs::metadata(path);

	match file {
		Ok(_) => true,
		Err(_) => false,
	}

}

fn check_if_dir(directory: String) -> bool {
	let path = directory + "/index.html";
	let result = check_if_path_exists(path);	

	return result;
}

fn generate_index(directory: String) -> String {

	let mut index = format!("<!DOCTYPE HTML><html><body><h1>Directory of {}</h1><hr/>", directory);
	for file in fs::read_dir(directory).unwrap() {
		index = format!("{}<br/><a href={}>{:#?}</a>", index, format!("\"./{}\"", file.as_ref().unwrap().path().display().to_string()), file.unwrap().file_name());
	}

	return format!("{}<hr/>Generated by herb {}", index, env!("CARGO_PKG_VERSION")).to_string();

}

fn get_page(filename: String) -> String {

	// The loaded page should be left immutable as it does
	// not need to be modified by the server.

	let path = filename.to_string();
	let checks = check_if_path_exists(path.clone());
	let index = check_if_dir(path.clone());

	println!("{} {} {}", path, checks, index);

	if checks == true && index == false {
		if path.contains(".") != true && path.contains(".cgi?") != true {
			let result = generate_index(filename);
			return result.to_string();
		} else if path.contains(".cgi?") {
			let result = process_cgi(filename);
			return result.to_string();
		}
	}

	if filename.contains(".cgi") {
		let result = process_cgi(filename);
		return result.to_string();
	} else {
		let result = fs::read_to_string(filename);
		match result {
			Ok(i) => i.to_string(),
			Err(_e) => "<!DOCTYPE HTML><html><body><h1>500 Internal Server Error</h1><p>The resource you are trying to access cannot be read by the server.</p></body></html>".to_string(),
		}
	
	}
} 

fn grab_time() -> String{
	let output = Command::new("date")
				.arg("+'%a, %d %b %Y %H:%m:%S %Z'")
				.output()
				.expect("failed to execute process");

	return String::from_utf8_lossy(&output.stdout).to_string().replace("'","").replace("\n","");
}


fn process_request(request: Vec<u8>) -> Resource { 
	let mut input = String::from_utf8_lossy(&request).to_string();

	let debug = false;

	let mut index = String::new();
	let output;
	if input.contains("GET") {		
		// To-do: find a less atrocious way to do this.
 		println!("Stream sent GET request.");
		
		if debug { println!("{}", input); }
		input = input.replace("GET ", "");
		input = input.replace(" HTTP/1.1\r\n", "");

		// Lynx also made me do this
		input = input.replace(" HTTP/1.0\r\n", "");

		// Theoretically by this point, the request
		// will have been cut down to just the
		// requested resource, but in my experience
		// this code is gonna result in like 50k errors
		// and I'm gonna have to rewrite it to get it
		// to actually work the way I want it to.

		if input != "/" {
			let mut chars = input.chars();
			chars.next();
			let path = chars.as_str().to_string();
			let exists = check_if_path_exists(path);
			let path = chars.as_str().to_string();

			if exists == false && path.contains(".cgi?") == false {
				let resource = Resource { contents: "<!DOCTYPE HTML><html><body><h1>404 Not Found</h1><p>The resource you are trying to locate cannot be accessed!</p></body></html>".to_string(), status_code: 404, mime: "text/html".to_string() };
				return resource;
			} else {
				let path = chars.as_str().to_string();
				let dir = check_if_dir(path);
				if dir == true {
					let path = chars.as_str().to_string();
					index += &path;
					index += "/index.html";
					output = index.as_str().clone();
				} else {
					output = chars.as_str();
				}
			}
		} else {
			output = "index.html";
		}


	} else {
		// It's get_page()'s problem now.
		let resource = Resource { contents: "<!DOCTYPE HTML><html><body><h1>501 Not Implemented</h1><p>The request sent by your web browser cannot be handled by this server software.</p></body></html>".to_string(), status_code: 501, mime: "text/html".to_string() };
		println!("Stream sent unhandlable request.");
		return resource;
	}

	// Did you want to see chars.as_str().to_string()?
	let mut resource = Resource { contents: get_page(output.to_string()), status_code: 200, mime: detect_media_type(output.to_string()) };
	if resource.contents.contains("500 Internal Server Error") {
		resource.status_code = 500;
		resource.mime = "text/html".to_string();
	}
	return resource;

}

fn serve(mut stream: TcpStream) {
	thread::spawn(move || {
		println!("Stream thread created.");
		let mut request = Vec::new();
		let mut reader = BufReader::new(&mut stream);
		reader
		    .read_until(b'\n', &mut request)
		    .expect("Failed to read from stream!");
	
		let resource = process_request(request);

		// let contents = get_page(resource.clone());
		// let header = "HTTP/1.1 200 OK\r\n";
		// let content_type = format!("Content-Type: {}\r\n", mime);
		// let server = format!("Server: herb/{}\r\n", env!("CARGO_PKG_VERSION"));
		// let extra_fields;

		let mut response_constructed = generate_response(resource.status_code, &resource.contents);
		response_constructed.headers.push(generate_kvheader("Content-Type", &resource.mime));
		response_constructed.headers.push(generate_kvheader("Server", &format!("herb/{}", env!("CARGO_PKG_VERSION"))));

		if cfg!(unix) {
			response_constructed.headers.push(generate_kvheader("Date", &grab_time()))
		} else {
			// I don't have a Windows or macOS box to test anything on
			// which means others are gonna have to deal with it :/
		}
	
		println!("{:#?}", response_constructed);
		stream.write(unpack_response(response_constructed).as_bytes()).unwrap();
		stream.flush().unwrap();
	});
}


fn main() -> std::io::Result<()> {
	let listen = TcpListener::bind("0.0.0.0:8080")?;

	for stream in listen.incoming() {
		println!("Serving incoming stream.");
		serve(stream?);
	}
	Ok(())
}
Handle URL rewriting for subdirectories containing index.html 2021-09-02 18:13:37 +01:00			`use std::io::{Write, BufReader, BufRead};`
Implement per-stream threading 2021-12-24 21:30:39 +00:00			`use std::thread;`
ZOMG IT WERKS 2021-08-29 16:07:05 +01:00			`use std::net::{TcpListener, TcpStream};`
Reading from filesystem is successful. 2021-08-30 16:17:11 +01:00			`use std::fs;`
			`use std::string::{String};`
Add date field but only on Unix hosts. Sorry friens who use Windows! 2021-12-22 20:30:53 +00:00			`use std::process::Command;`
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`use packeteer::http1::*;`
			`use packeteer::generate_kvheader;`

			`struct Resource {`
			`contents: String,`
			`status_code: i32,`
			`mime: String,`
			`}`
Reading from filesystem is successful. 2021-08-30 16:17:11 +01:00
Implement dynamic content via CGI and fix media type detection errors with server error pages. 2021-12-26 17:29:34 +00:00			`fn process_cgi(filename: String) -> String {`
			`// This is gonna be the boggiest implementation of CGI that anyone`
			`// has ever seen in the history of the fucking world`

			`let query;`
			`let script;`

			`if filename.contains("?") {`
			`let vars = filename.to_string().find("?").unwrap();`
			`let vars1 = vars + 1;`
			`query = &filename[vars1..];`
			`script = &filename[..vars];`
			`} else {`
			`query = "";`
			`script = &filename;`
			`}`
Fix CGI implementation 2022-08-28 10:42:32 +01:00			`println!("{}", script);`
Implement dynamic content via CGI and fix media type detection errors with server error pages. 2021-12-26 17:29:34 +00:00
0.4.2: If there is no query string for CGI then the QUERY_STRING env var isn't set. 2022-09-17 09:37:42 +01:00			`let output;`
			`if query != "" {`
			`output = Command::new(format!("./{}", script))`
			`.env("GATEWAY_INTERFACE", "CGI/1.1")`
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`.env("SERVER_SOFTWARE", format!("herb/{}", env!("CARGO_PKG_VERSION")))`
0.4.2: If there is no query string for CGI then the QUERY_STRING env var isn't set. 2022-09-17 09:37:42 +01:00			`.env("REQUEST_METHOD", "GET")`
			`.env("QUERY_STRING", query)`
			`.env("SCRIPT_NAME", script)`
			`.output()`
			`.expect("failed to execute process");`
			`} else {`
			`output = Command::new(format!("./{}", script))`
			`.env("GATEWAY_INTERFACE", "CGI/1.1")`
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`.env("SERVER_SOFTWARE", format!("herb/{}", env!("CARGO_PKG_VERSION")))`
0.4.2: If there is no query string for CGI then the QUERY_STRING env var isn't set. 2022-09-17 09:37:42 +01:00			`.env("REQUEST_METHOD", "GET")`
			`.env("SCRIPT_NAME", script)`
			`.output()`
			`.expect("failed to execute process");`
			`}`
Implement dynamic content via CGI and fix media type detection errors with server error pages. 2021-12-26 17:29:34 +00:00			`let outputd = String::from_utf8_lossy(&output.stdout).to_string();`
			`return outputd;`
			`}`

Add media type detection and server fields. 2021-12-22 20:02:09 +00:00			`fn detect_media_type(filename: String) -> String {`

			`// The Lynx terminal browser made me do this.`

Implement dynamic content via CGI and fix media type detection errors with server error pages. 2021-12-26 17:29:34 +00:00			`let path = filename.to_string();`
			`let paths = check_if_path_exists(path);`
			`let path = filename.to_string();`
			`let dir = check_if_dir(path);`

			`if paths == true && dir == false && filename.contains(".") == false {`
			`return "text/html".to_string();`
			`} else {`
			`let ext_index = filename.to_string().find(".").unwrap();`
			`let test = ext_index + 1;`
			`let ext = &filename[test..];`

			`if filename[test..].contains("cgi") { return "text/html".to_string(); }`

			`match ext {`
			`"aac" => "audio/aac".to_string(),`
			`"avi" => "video/x-msvideo".to_string(),`
			`"bmp" => "image/bmp".to_string(),`
			`"bz2" => "application/x-bzip2".to_string(),`
			`"css" => "text/css".to_string(),`
			`"gz" => "application/gzip".to_string(),`
			`"gif" => "image/gif".to_string(),`
			`"png" => "image/png".to_string(),`
			`"pdf" => "application/pdf".to_string(),`
			`"jpeg" => "image/jpeg".to_string(),`
			`"jpg" => "image/jpeg".to_string(),`
			`"js" => "text/javascript".to_string(),`
			`"mid" => "audio/midi".to_string(),`
			`"midi" => "audio/midi".to_string(),`
			`"mp3" => "audio/mpeg".to_string(),`
			`"mp4" => "video/mp4".to_string(),`
			`"mpeg" => "video/mpeg".to_string(),`
			`"ogg" => "audio/ogg".to_string(),`
			`"oga" => "audio/ogg".to_string(),`
			`"ogv" => "video/ogg".to_string(),`
			`"opus" => "audio/opus".to_string(),`
			`"txt" => "text/plain".to_string(),`
			`"html" => "text/html".to_string(),`
			`"htm" => "text/html".to_string(),`
			`"cgi" => "text/html".to_string(),`
			`".error_server_404" => "text/html".to_string(),`
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`".error_server_501" => "text/html".to_string(),`
Implement dynamic content via CGI and fix media type detection errors with server error pages. 2021-12-26 17:29:34 +00:00			`_ => "application/octet-stream".to_string(),`
			`}`
Add media type detection and server fields. 2021-12-22 20:02:09 +00:00			`}`

			`}`

Handle URL rewriting for subdirectories containing index.html 2021-09-02 18:13:37 +01:00			`fn check_if_path_exists(path: String) -> bool {`

			`// This is probably not the best way of checking if a path`
			`// exists but I don't care :)`

			`let file = fs::metadata(path);`

			`match file {`
			`Ok(_) => true,`
			`Err(_) => false,`
			`}`

			`}`

			`fn check_if_dir(directory: String) -> bool {`
			`let path = directory + "/index.html";`
			`let result = check_if_path_exists(path);`

			`return result;`
			`}`

Directory index generation works 2021-09-05 16:16:07 +01:00			`fn generate_index(directory: String) -> String {`

Decorate index page. 2021-12-26 18:27:56 +00:00			`let mut index = format!("<!DOCTYPE HTML><html><body><h1>Directory of {}</h1><hr/>", directory);`
Directory index generation works 2021-09-05 16:16:07 +01:00			`for file in fs::read_dir(directory).unwrap() {`
Decorate index page. 2021-12-26 18:27:56 +00:00			`index = format!("{}<br/><a href={}>{:#?}</a>", index, format!("\"./{}\"", file.as_ref().unwrap().path().display().to_string()), file.unwrap().file_name());`
Directory index generation works 2021-09-05 16:16:07 +01:00			`}`

rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`return format!("{}<hr/>Generated by herb {}", index, env!("CARGO_PKG_VERSION")).to_string();`
Directory index generation works 2021-09-05 16:16:07 +01:00
			`}`

Bad requests are handled with 503 errors and process_request() now removes character returns and line feeds at the end of a request :) 2021-09-02 17:25:53 +01:00			`fn get_page(filename: String) -> String {`
Requests can now be parsed and compiler warnings are fewer. 2021-09-02 16:16:38 +01:00
Reading from filesystem is successful. 2021-08-30 16:17:11 +01:00			`// The loaded page should be left immutable as it does`
			`// not need to be modified by the server.`

Directory index generation works 2021-09-05 16:16:07 +01:00			`let path = filename.to_string();`
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`let checks = check_if_path_exists(path.clone());`
			`let index = check_if_dir(path.clone());`
Directory index generation works 2021-09-05 16:16:07 +01:00
			`println!("{} {} {}", path, checks, index);`

			`if checks == true && index == false {`
Implement dynamic content via CGI and fix media type detection errors with server error pages. 2021-12-26 17:29:34 +00:00			`if path.contains(".") != true && path.contains(".cgi?") != true {`
Directory index generation works 2021-09-05 16:16:07 +01:00			`let result = generate_index(filename);`
Implement dynamic content via CGI and fix media type detection errors with server error pages. 2021-12-26 17:29:34 +00:00			`return result.to_string();`
			`} else if path.contains(".cgi?") {`
			`let result = process_cgi(filename);`
Directory index generation works 2021-09-05 16:16:07 +01:00			`return result.to_string();`
			`}`
			`}`

rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`if filename.contains(".cgi") {`
Implement dynamic content via CGI and fix media type detection errors with server error pages. 2021-12-26 17:29:34 +00:00			`let result = process_cgi(filename);`
			`return result.to_string();`
Bad requests are handled with 503 errors and process_request() now removes character returns and line feeds at the end of a request :) 2021-09-02 17:25:53 +01:00			`} else {`
			`let result = fs::read_to_string(filename);`
			`match result {`
			`Ok(i) => i.to_string(),`
switch 403 forbidden to 500 Internal Server Error 2022-08-28 10:54:00 +01:00			`Err(_e) => "<!DOCTYPE HTML><html><body><h1>500 Internal Server Error</h1><p>The resource you are trying to access cannot be read by the server.</p></body></html>".to_string(),`
Bad requests are handled with 503 errors and process_request() now removes character returns and line feeds at the end of a request :) 2021-09-02 17:25:53 +01:00			`}`

Handle filesystem errors by presuming 404. 2021-08-30 17:32:44 +01:00			`}`
Reading from filesystem is successful. 2021-08-30 16:17:11 +01:00			`}`
ZOMG IT WERKS 2021-08-29 16:07:05 +01:00
Add date field but only on Unix hosts. Sorry friens who use Windows! 2021-12-22 20:30:53 +00:00			`fn grab_time() -> String{`
			`let output = Command::new("date")`
			`.arg("+'%a, %d %b %Y %H:%m:%S %Z'")`
			`.output()`
			`.expect("failed to execute process");`

rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`return String::from_utf8_lossy(&output.stdout).to_string().replace("'","").replace("\n","");`
Add date field but only on Unix hosts. Sorry friens who use Windows! 2021-12-22 20:30:53 +00:00			`}`


rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`fn process_request(request: Vec<u8>) -> Resource {`
Requests can now be parsed and compiler warnings are fewer. 2021-09-02 16:16:38 +01:00			`let mut input = String::from_utf8_lossy(&request).to_string();`
Handle URL rewriting for subdirectories containing index.html 2021-09-02 18:13:37 +01:00
Add media type detection and server fields. 2021-12-22 20:02:09 +00:00			`let debug = false;`

Handle URL rewriting for subdirectories containing index.html 2021-09-02 18:13:37 +01:00			`let mut index = String::new();`
Stack Overflow, what would I ever do without you? 2021-09-02 16:18:23 +01:00			`let output;`
Requests can now be parsed and compiler warnings are fewer. 2021-09-02 16:16:38 +01:00			`if input.contains("GET") {`
			`// To-do: find a less atrocious way to do this.`
Remove debug messages as I went insane trying to fix the tiny CRLF problem in process_request() 2021-09-02 17:28:07 +01:00			`println!("Stream sent GET request.");`
Add media type detection and server fields. 2021-12-22 20:02:09 +00:00
			`if debug { println!("{}", input); }`
Requests can now be parsed and compiler warnings are fewer. 2021-09-02 16:16:38 +01:00			`input = input.replace("GET ", "");`
Bad requests are handled with 503 errors and process_request() now removes character returns and line feeds at the end of a request :) 2021-09-02 17:25:53 +01:00			`input = input.replace(" HTTP/1.1\r\n", "");`
Add media type detection and server fields. 2021-12-22 20:02:09 +00:00
			`// Lynx also made me do this`
			`input = input.replace(" HTTP/1.0\r\n", "");`

Requests can now be parsed and compiler warnings are fewer. 2021-09-02 16:16:38 +01:00			`// Theoretically by this point, the request`
			`// will have been cut down to just the`
			`// requested resource, but in my experience`
			`// this code is gonna result in like 50k errors`
			`// and I'm gonna have to rewrite it to get it`
			`// to actually work the way I want it to.`

Bad requests are handled with 503 errors and process_request() now removes character returns and line feeds at the end of a request :) 2021-09-02 17:25:53 +01:00			`if input != "/" {`
And the resource has been isolated! 2021-09-02 16:25:13 +01:00			`let mut chars = input.chars();`
			`chars.next();`
Handle URL rewriting for subdirectories containing index.html 2021-09-02 18:13:37 +01:00			`let path = chars.as_str().to_string();`
			`let exists = check_if_path_exists(path);`
Implement dynamic content via CGI and fix media type detection errors with server error pages. 2021-12-26 17:29:34 +00:00			`let path = chars.as_str().to_string();`

			`if exists == false && path.contains(".cgi?") == false {`
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`let resource = Resource { contents: "<!DOCTYPE HTML><html><body><h1>404 Not Found</h1><p>The resource you are trying to locate cannot be accessed!</p></body></html>".to_string(), status_code: 404, mime: "text/html".to_string() };`
			`return resource;`
Handle URL rewriting for subdirectories containing index.html 2021-09-02 18:13:37 +01:00			`} else {`
			`let path = chars.as_str().to_string();`
			`let dir = check_if_dir(path);`
			`if dir == true {`
			`let path = chars.as_str().to_string();`
			`index += &path;`
			`index += "/index.html";`
			`output = index.as_str().clone();`
			`} else {`
			`output = chars.as_str();`
			`}`
			`}`
Bad requests are handled with 503 errors and process_request() now removes character returns and line feeds at the end of a request :) 2021-09-02 17:25:53 +01:00			`} else {`
			`output = "index.html";`
Requests can now be parsed and compiler warnings are fewer. 2021-09-02 16:16:38 +01:00			`}`

Bad requests are handled with 503 errors and process_request() now removes character returns and line feeds at the end of a request :) 2021-09-02 17:25:53 +01:00
Requests can now be parsed and compiler warnings are fewer. 2021-09-02 16:16:38 +01:00			`} else {`
			`// It's get_page()'s problem now.`
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`let resource = Resource { contents: "<!DOCTYPE HTML><html><body><h1>501 Not Implemented</h1><p>The request sent by your web browser cannot be handled by this server software.</p></body></html>".to_string(), status_code: 501, mime: "text/html".to_string() };`
Handle URL rewriting for subdirectories containing index.html 2021-09-02 18:13:37 +01:00			`println!("Stream sent unhandlable request.");`
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`return resource;`
Requests can now be parsed and compiler warnings are fewer. 2021-09-02 16:16:38 +01:00			`}`
And the resource has been isolated! 2021-09-02 16:25:13 +01:00
			`// Did you want to see chars.as_str().to_string()?`
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`let mut resource = Resource { contents: get_page(output.to_string()), status_code: 200, mime: detect_media_type(output.to_string()) };`
			`if resource.contents.contains("500 Internal Server Error") {`
			`resource.status_code = 500;`
			`resource.mime = "text/html".to_string();`
			`}`
			`return resource;`
Handle filesystem errors by presuming 404. 2021-08-30 17:32:44 +01:00
Reading the stream is successful. 2021-08-30 17:18:22 +01:00			`}`

ZOMG IT WERKS 2021-08-29 16:07:05 +01:00			`fn serve(mut stream: TcpStream) {`
Implement per-stream threading 2021-12-24 21:30:39 +00:00			`thread::spawn(move \|\| {`
			`println!("Stream thread created.");`
			`let mut request = Vec::new();`
			`let mut reader = BufReader::new(&mut stream);`
			`reader`
			`.read_until(b'\n', &mut request)`
			`.expect("Failed to read from stream!");`
Reading the stream is successful. 2021-08-30 17:18:22 +01:00
Implement per-stream threading 2021-12-24 21:30:39 +00:00			`let resource = process_request(request);`
Add media type detection and server fields. 2021-12-22 20:02:09 +00:00
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`// let contents = get_page(resource.clone());`
			`// let header = "HTTP/1.1 200 OK\r\n";`
			`// let content_type = format!("Content-Type: {}\r\n", mime);`
			`// let server = format!("Server: herb/{}\r\n", env!("CARGO_PKG_VERSION"));`
			`// let extra_fields;`
Add media type detection and server fields. 2021-12-22 20:02:09 +00:00
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`let mut response_constructed = generate_response(resource.status_code, &resource.contents);`
			`response_constructed.headers.push(generate_kvheader("Content-Type", &resource.mime));`
			`response_constructed.headers.push(generate_kvheader("Server", &format!("herb/{}", env!("CARGO_PKG_VERSION"))));`
Add autoswitch for time field to disable on non-Unix systems to prevent potential crashes. 2021-12-22 20:38:36 +00:00
Implement per-stream threading 2021-12-24 21:30:39 +00:00			`if cfg!(unix) {`
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`response_constructed.headers.push(generate_kvheader("Date", &grab_time()))`
Implement per-stream threading 2021-12-24 21:30:39 +00:00			`} else {`
			`// I don't have a Windows or macOS box to test anything on`
			`// which means others are gonna have to deal with it :/`
			`}`
Reading from filesystem is successful. 2021-08-30 16:17:11 +01:00
rework to use packeteer and fix status codes, clean up code 2023-10-19 11:24:36 +01:00			`println!("{:#?}", response_constructed);`
			`stream.write(unpack_response(response_constructed).as_bytes()).unwrap();`
Implement per-stream threading 2021-12-24 21:30:39 +00:00			`stream.flush().unwrap();`
			`});`
ZOMG IT WERKS 2021-08-29 16:07:05 +01:00			`}`


			`fn main() -> std::io::Result<()> {`
Add date field but only on Unix hosts. Sorry friens who use Windows! 2021-12-22 20:30:53 +00:00			`let listen = TcpListener::bind("0.0.0.0:8080")?;`
ZOMG IT WERKS 2021-08-29 16:07:05 +01:00
			`for stream in listen.incoming() {`
Reading the stream is successful. 2021-08-30 17:18:22 +01:00			`println!("Serving incoming stream.");`
ZOMG IT WERKS 2021-08-29 16:07:05 +01:00			`serve(stream?);`
			`}`
			`Ok(())`
Cargo init 2021-08-29 15:18:20 +01:00			`}`