diff --git a/src/client.rs b/src/client.rs
index 9ec5215..76bae36 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -60,7 +60,7 @@ async fn stream(url: &str, req: &Request
) -> Result, String
.map_err(|e| e.to_string())
}
-fn request(url: String) -> Boxed, String>> {
+fn request(url: String, quarantine: bool) -> Boxed, String>> {
// Prepare the HTTPS connector.
let https = hyper_rustls::HttpsConnector::with_native_roots();
@@ -75,6 +75,7 @@ fn request(url: String) -> Boxed, String>> {
.header("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8")
.header("Accept-Language", "en-US,en;q=0.5")
.header("Connection", "keep-alive")
+ .header("Cookie", if quarantine { "_options=%7B%22pref_quarantine_optin%22%3A%20true%7D" } else { "" })
.body(Body::empty());
async move {
@@ -89,6 +90,7 @@ fn request(url: String) -> Boxed, String>> {
.map(|val| val.to_str().unwrap_or_default())
.unwrap_or_default()
.to_string(),
+ quarantine,
)
.await
} else {
@@ -105,7 +107,7 @@ fn request(url: String) -> Boxed, String>> {
// Make a request to a Reddit API and parse the JSON response
#[cached(size = 100, time = 30, result = true)]
-pub async fn json(path: String) -> Result {
+pub async fn json(path: String, quarantine: bool) -> Result {
// Build Reddit url from path
let url = format!("https://www.reddit.com{}", path);
@@ -116,7 +118,7 @@ pub async fn json(path: String) -> Result {
};
// Fetch the url...
- match request(url.clone()).await {
+ match request(url.clone(), quarantine).await {
Ok(response) => {
// asynchronously aggregate the chunks of the body
match hyper::body::aggregate(response).await {
diff --git a/src/main.rs b/src/main.rs
index c26d093..5034b83 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -194,7 +194,10 @@ async fn main() {
app.at("/settings/update").get(|r| settings::update(r).boxed());
// Subreddit services
- app.at("/r/:sub").get(|r| subreddit::community(r).boxed());
+ app
+ .at("/r/:sub")
+ .get(|r| subreddit::community(r).boxed())
+ .post(|r| subreddit::add_quarantine_exception(r).boxed());
app
.at("/r/u_:name")
diff --git a/src/post.rs b/src/post.rs
index 94d87e9..f6f3226 100644
--- a/src/post.rs
+++ b/src/post.rs
@@ -2,7 +2,9 @@
use crate::client::json;
use crate::esc;
use crate::server::RequestExt;
+use crate::subreddit::{can_access_quarantine, quarantine};
use crate::utils::{error, format_num, format_url, param, rewrite_urls, setting, template, time, val, Author, Comment, Flags, Flair, FlairPart, Media, Post, Preferences};
+
use hyper::{Body, Request, Response};
use async_recursion::async_recursion;
@@ -23,18 +25,22 @@ struct PostTemplate {
pub async fn item(req: Request) -> Result, String> {
// Build Reddit API path
let mut path: String = format!("{}.json?{}&raw_json=1", req.uri().path(), req.uri().query().unwrap_or_default());
+ let sub = req.param("sub").unwrap_or_default();
+ let quarantined = can_access_quarantine(&req, &sub);
// Set sort to sort query parameter
- let mut sort: String = param(&path, "sort");
+ let sort = param(&path, "sort").unwrap_or_else(|| {
+ // Grab default comment sort method from Cookies
+ let default_sort = setting(&req, "comment_sort");
- // Grab default comment sort method from Cookies
- let default_sort = setting(&req, "comment_sort");
-
- // If there's no sort query but there's a default sort, set sort to default_sort
- if sort.is_empty() && !default_sort.is_empty() {
- sort = default_sort;
- path = format!("{}.json?{}&sort={}&raw_json=1", req.uri().path(), req.uri().query().unwrap_or_default(), sort);
- }
+ // If there's no sort query but there's a default sort, set sort to default_sort
+ if !default_sort.is_empty() {
+ path = format!("{}.json?{}&sort={}&raw_json=1", req.uri().path(), req.uri().query().unwrap_or_default(), default_sort);
+ default_sort
+ } else {
+ String::new()
+ }
+ });
// Log the post ID being fetched in debug mode
#[cfg(debug_assertions)]
@@ -44,7 +50,7 @@ pub async fn item(req: Request) -> Result, String> {
let highlighted_comment = &req.param("comment_id").unwrap_or_default();
// Send a request to the url, receive JSON in response
- match json(path).await {
+ match json(path, quarantined).await {
// Otherwise, grab the JSON output from the request
Ok(res) => {
// Parse the JSON into Post and Comment structs
@@ -61,7 +67,14 @@ pub async fn item(req: Request) -> Result, String> {
})
}
// If the Reddit API returns an error, exit and send error page to user
- Err(msg) => error(req, msg).await,
+ Err(msg) => {
+ if msg == "quarantined" {
+ let sub = req.param("sub").unwrap_or_default();
+ quarantine(req, sub)
+ } else {
+ error(req, msg).await
+ }
+ }
}
}
diff --git a/src/search.rs b/src/search.rs
index de75f0b..c0a7e99 100644
--- a/src/search.rs
+++ b/src/search.rs
@@ -1,6 +1,10 @@
// CRATES
use crate::utils::{catch_random, error, format_num, format_url, param, setting, template, val, Post, Preferences};
-use crate::{client::json, RequestExt};
+use crate::{
+ client::json,
+ subreddit::{can_access_quarantine, quarantine},
+ RequestExt,
+};
use askama::Template;
use hyper::{Body, Request, Response};
@@ -39,27 +43,23 @@ pub async fn find(req: Request) -> Result, String> {
let nsfw_results = if setting(&req, "show_nsfw") == "on" { "&include_over_18=on" } else { "" };
let path = format!("{}.json?{}{}", req.uri().path(), req.uri().query().unwrap_or_default(), nsfw_results);
let sub = req.param("sub").unwrap_or_default();
+ let quarantined = can_access_quarantine(&req, &sub);
// Handle random subreddits
if let Ok(random) = catch_random(&sub, "/find").await {
return Ok(random);
}
- let query = param(&path, "q");
+ let query = param(&path, "q").unwrap_or_default();
- let sort = if param(&path, "sort").is_empty() {
- "relevance".to_string()
- } else {
- param(&path, "sort")
- };
+ let sort = param(&path, "sort").unwrap_or("relevance".to_string());
- let subreddits = if param(&path, "restrict_sr").is_empty() {
- search_subreddits(&query).await
- } else {
- Vec::new()
+ let subreddits = match param(&path, "restrict_sr") {
+ None => search_subreddits(&query).await,
+ Some(_) => Vec::new()
};
let url = String::from(req.uri().path_and_query().map_or("", |val| val.as_str()));
- match Post::fetch(&path, String::new()).await {
+ match Post::fetch(&path, String::new(), quarantined).await {
Ok((posts, after)) => template(SearchTemplate {
posts,
subreddits,
@@ -67,15 +67,22 @@ pub async fn find(req: Request) -> Result, String> {
params: SearchParams {
q: query.replace('"', """),
sort,
- t: param(&path, "t"),
- before: param(&path, "after"),
+ t: param(&path, "t").unwrap_or_default(),
+ before: param(&path, "after").unwrap_or_default(),
after,
- restrict_sr: param(&path, "restrict_sr"),
+ restrict_sr: param(&path, "restrict_sr").unwrap_or_default(),
},
prefs: Preferences::new(req),
url,
}),
- Err(msg) => error(req, msg).await,
+ Err(msg) => {
+ if msg == "quarantined" {
+ let sub = req.param("sub").unwrap_or_default();
+ quarantine(req, sub)
+ } else {
+ error(req, msg).await
+ }
+ }
}
}
@@ -83,7 +90,7 @@ async fn search_subreddits(q: &str) -> Vec {
let subreddit_search_path = format!("/subreddits/search.json?q={}&limit=3", q.replace(' ', "+"));
// Send a request to the url
- match json(subreddit_search_path).await {
+ match json(subreddit_search_path, false).await {
// If success, receive JSON in response
Ok(response) => {
match response["data"]["children"].as_array() {
diff --git a/src/subreddit.rs b/src/subreddit.rs
index 8c4a228..0477eb2 100644
--- a/src/subreddit.rs
+++ b/src/subreddit.rs
@@ -28,9 +28,20 @@ struct WikiTemplate {
prefs: Preferences,
}
+#[derive(Template)]
+#[template(path = "wall.html", escape = "none")]
+struct WallTemplate {
+ title: String,
+ sub: String,
+ msg: String,
+ prefs: Preferences,
+ url: String,
+}
+
// SERVICES
pub async fn community(req: Request) -> Result, String> {
// Build Reddit API path
+ let root = req.uri().path() == "/";
let subscribed = setting(&req, "subscriptions");
let front_page = setting(&req, "front_page");
let post_sort = req.cookie("post_sort").map_or_else(|| "hot".to_string(), |c| c.value().to_string());
@@ -45,6 +56,7 @@ pub async fn community(req: Request) -> Result, String> {
} else {
front_page.to_owned()
});
+ let quarantined = can_access_quarantine(&req, &sub) || root;
// Handle random subreddits
if let Ok(random) = catch_random(&sub, "").await {
@@ -57,16 +69,16 @@ pub async fn community(req: Request) -> Result, String> {
let path = format!("/r/{}/{}.json?{}&raw_json=1", sub, sort, req.uri().query().unwrap_or_default());
- match Post::fetch(&path, String::new()).await {
+ match Post::fetch(&path, String::new(), quarantined).await {
Ok((posts, after)) => {
// If you can get subreddit posts, also request subreddit metadata
let sub = if !sub.contains('+') && sub != subscribed && sub != "popular" && sub != "all" {
// Regular subreddit
- subreddit(&sub).await.unwrap_or_default()
+ subreddit(&sub, quarantined).await.unwrap_or_default()
} else if sub == subscribed {
// Subscription feed
if req.uri().path().starts_with("/r/") {
- subreddit(&sub).await.unwrap_or_default()
+ subreddit(&sub, quarantined).await.unwrap_or_default()
} else {
Subreddit::default()
}
@@ -85,14 +97,14 @@ pub async fn community(req: Request) -> Result, String> {
template(SubredditTemplate {
sub,
posts,
- sort: (sort, param(&path, "t")),
- ends: (param(&path, "after"), after),
+ sort: (sort, param(&path, "t").unwrap_or_default()),
+ ends: (param(&path, "after").unwrap_or_default(), after),
prefs: Preferences::new(req),
url,
})
}
Err(msg) => match msg.as_str() {
- "quarantined" => error(req, format!("r/{} has been quarantined by Reddit", sub)).await,
+ "quarantined" => quarantine(req, sub),
"private" => error(req, format!("r/{} is a private community", sub)).await,
"banned" => error(req, format!("r/{} has been banned from Reddit", sub)).await,
_ => error(req, msg).await,
@@ -100,6 +112,43 @@ pub async fn community(req: Request) -> Result, String> {
}
}
+pub fn quarantine(req: Request, sub: String) -> Result, String> {
+ let wall = WallTemplate {
+ title: format!("r/{} is quarantined", sub),
+ msg: "Please click the button below to continue to this subreddit.".to_string(),
+ url: req.uri().to_string(),
+ sub,
+ prefs: Preferences::new(req),
+ };
+
+ Ok(
+ Response::builder()
+ .status(403)
+ .header("content-type", "text/html")
+ .body(wall.render().unwrap_or_default().into())
+ .unwrap_or_default(),
+ )
+}
+
+pub async fn add_quarantine_exception(req: Request) -> Result, String> {
+ let subreddit = req.param("sub").ok_or("Invalid URL")?;
+ let redir = param(&format!("?{}", req.uri().query().unwrap_or_default()), "redir").ok_or("Invalid URL")?;
+ let mut res = redirect(redir.to_owned());
+ res.insert_cookie(
+ Cookie::build(&format!("allow_quaran_{}", subreddit.to_lowercase()), "true")
+ .path("/")
+ .http_only(true)
+ .expires(cookie::Expiration::Session)
+ .finish(),
+ );
+ Ok(res)
+}
+
+pub fn can_access_quarantine(req: &Request, sub: &str) -> bool {
+ // Determine if the subreddit can be accessed
+ setting(&req, &format!("allow_quaran_{}", sub.to_lowercase())).parse().unwrap_or_default()
+}
+
// Sub or unsub by setting subscription cookie using response "Set-Cookie" header
pub async fn subscriptions(req: Request) -> Result, String> {
let sub = req.param("sub").unwrap_or_default();
@@ -114,7 +163,7 @@ pub async fn subscriptions(req: Request) -> Result, String>
let mut sub_list = Preferences::new(req).subscriptions;
// Retrieve list of posts for these subreddits to extract display names
- let posts = json(format!("/r/{}/hot.json?raw_json=1", sub)).await?;
+ let posts = json(format!("/r/{}/hot.json?raw_json=1", sub), true).await?;
let display_lookup: Vec<(String, &str)> = posts["data"]["children"]
.as_array()
.map(|list| {
@@ -138,7 +187,7 @@ pub async fn subscriptions(req: Request) -> Result, String>
} else {
// This subreddit display name isn't known, retrieve it
let path: String = format!("/r/{}/about.json?raw_json=1", part);
- display = json(path).await?;
+ display = json(path, true).await?;
display["data"]["display_name"].as_str().ok_or_else(|| "Failed to query subreddit name".to_string())?
};
@@ -156,11 +205,9 @@ pub async fn subscriptions(req: Request) -> Result, String>
// Redirect back to subreddit
// check for redirect parameter if unsubscribing from outside sidebar
- let redirect_path = param(&format!("/?{}", query), "redirect");
- let path = if redirect_path.is_empty() {
- format!("/r/{}", sub)
- } else {
- format!("/{}/", redirect_path)
+ let path = match param(&format!("?{}", query), "redirect") {
+ Some(redirect_path) => format!("/{}/", redirect_path),
+ None => format!("/r/{}", sub)
};
let mut res = redirect(path);
@@ -183,6 +230,7 @@ pub async fn subscriptions(req: Request) -> Result, String>
pub async fn wiki(req: Request) -> Result, String> {
let sub = req.param("sub").unwrap_or_else(|| "reddit.com".to_string());
+ let quarantined = can_access_quarantine(&req, &sub);
// Handle random subreddits
if let Ok(random) = catch_random(&sub, "/wiki").await {
return Ok(random);
@@ -191,19 +239,26 @@ pub async fn wiki(req: Request) -> Result, String> {
let page = req.param("page").unwrap_or_else(|| "index".to_string());
let path: String = format!("/r/{}/wiki/{}.json?raw_json=1", sub, page);
- match json(path).await {
+ match json(path, quarantined).await {
Ok(response) => template(WikiTemplate {
sub,
wiki: rewrite_urls(response["data"]["content_html"].as_str().unwrap_or("Wiki not found
")),
page,
prefs: Preferences::new(req),
}),
- Err(msg) => error(req, msg).await,
+ Err(msg) => {
+ if msg == "quarantined" {
+ quarantine(req, sub)
+ } else {
+ error(req, msg).await
+ }
+ }
}
}
pub async fn sidebar(req: Request) -> Result, String> {
let sub = req.param("sub").unwrap_or_else(|| "reddit.com".to_string());
+ let quarantined = can_access_quarantine(&req, &sub);
// Handle random subreddits
if let Ok(random) = catch_random(&sub, "/about/sidebar").await {
return Ok(random);
@@ -213,26 +268,32 @@ pub async fn sidebar(req: Request) -> Result, String> {
let path: String = format!("/r/{}/about.json?raw_json=1", sub);
// Send a request to the url
- match json(path).await {
+ match json(path, quarantined).await {
// If success, receive JSON in response
Ok(response) => template(WikiTemplate {
wiki: format!(
"{}
Moderators
",
rewrite_urls(&val(&response, "description_html").replace("\\", "")),
- moderators(&sub).await?.join(""),
+ moderators(&sub, quarantined).await?.join(""),
),
sub,
page: "Sidebar".to_string(),
prefs: Preferences::new(req),
}),
- Err(msg) => error(req, msg).await,
+ Err(msg) => {
+ if msg == "quarantined" {
+ quarantine(req, sub)
+ } else {
+ error(req, msg).await
+ }
+ }
}
}
-pub async fn moderators(sub: &str) -> Result, String> {
+pub async fn moderators(sub: &str, quarantined: bool) -> Result, String> {
// Retrieve and format the html for the moderators list
Ok(
- moderators_list(sub)
+ moderators_list(sub, quarantined)
.await?
.iter()
.map(|m| format!("{name}", name = m))
@@ -240,12 +301,12 @@ pub async fn moderators(sub: &str) -> Result, String> {
)
}
-async fn moderators_list(sub: &str) -> Result, String> {
+async fn moderators_list(sub: &str, quarantined: bool) -> Result, String> {
// Build the moderator list URL
let path: String = format!("/r/{}/about/moderators.json?raw_json=1", sub);
// Retrieve response
- let response = json(path).await?["data"]["children"].clone();
+ let response = json(path, quarantined).await?["data"]["children"].clone();
Ok(
// Traverse json tree and format into list of strings
response
@@ -265,12 +326,12 @@ async fn moderators_list(sub: &str) -> Result, String> {
}
// SUBREDDIT
-async fn subreddit(sub: &str) -> Result {
+async fn subreddit(sub: &str, quarantined: bool) -> Result {
// Build the Reddit JSON API url
let path: String = format!("/r/{}/about.json?raw_json=1", sub);
// Send a request to the url
- match json(path).await {
+ match json(path, quarantined).await {
// If success, receive JSON in response
Ok(res) => {
// Metadata regarding the subreddit
@@ -286,7 +347,7 @@ async fn subreddit(sub: &str) -> Result {
title: esc!(&res, "title"),
description: esc!(&res, "public_description"),
info: rewrite_urls(&val(&res, "description_html").replace("\\", "")),
- moderators: moderators_list(sub).await?,
+ moderators: moderators_list(sub, quarantined).await?,
icon: format_url(&icon),
members: format_num(members),
active: format_num(active),
diff --git a/src/user.rs b/src/user.rs
index 2ba024f..199653a 100644
--- a/src/user.rs
+++ b/src/user.rs
@@ -29,11 +29,11 @@ pub async fn profile(req: Request) -> Result, String> {
);
// Retrieve other variables from Libreddit request
- let sort = param(&path, "sort");
+ let sort = param(&path, "sort").unwrap_or_default();
let username = req.param("name").unwrap_or_default();
// Request user posts/comments from Reddit
- let posts = Post::fetch(&path, "Comment".to_string()).await;
+ let posts = Post::fetch(&path, "Comment".to_string(), false).await;
let url = String::from(req.uri().path_and_query().map_or("", |val| val.as_str()));
match posts {
@@ -44,8 +44,8 @@ pub async fn profile(req: Request) -> Result, String> {
template(UserTemplate {
user,
posts,
- sort: (sort, param(&path, "t")),
- ends: (param(&path, "after"), after),
+ sort: (sort, param(&path, "t").unwrap_or_default()),
+ ends: (param(&path, "after").unwrap_or_default(), after),
prefs: Preferences::new(req),
url,
})
@@ -61,7 +61,7 @@ async fn user(name: &str) -> Result {
let path: String = format!("/user/{}/about.json?raw_json=1", name);
// Send a request to the url
- match json(path).await {
+ match json(path, false).await {
// If success, receive JSON in response
Ok(res) => {
// Grab creation date as unix timestamp
diff --git a/src/utils.rs b/src/utils.rs
index e65e2b3..8147815 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -217,12 +217,12 @@ pub struct Post {
impl Post {
// Fetch posts of a user or subreddit and return a vector of posts and the "after" value
- pub async fn fetch(path: &str, fallback_title: String) -> Result<(Vec, String), String> {
+ pub async fn fetch(path: &str, fallback_title: String, quarantine: bool) -> Result<(Vec, String), String> {
let res;
let post_list;
// Send a request to the url
- match json(path.to_string()).await {
+ match json(path.to_string(), quarantine).await {
// If success, receive JSON in response
Ok(response) => {
res = response;
@@ -416,11 +416,16 @@ impl Preferences {
//
// Grab a query parameter from a url
-pub fn param(path: &str, value: &str) -> String {
- match Url::parse(format!("https://libredd.it/{}", path).as_str()) {
- Ok(url) => url.query_pairs().into_owned().collect::>().get(value).unwrap_or(&String::new()).to_owned(),
- _ => String::new(),
- }
+pub fn param(path: &str, value: &str) -> Option {
+ Some(
+ Url::parse(format!("https://libredd.it/{}", path).as_str())
+ .ok()?
+ .query_pairs()
+ .into_owned()
+ .collect::>()
+ .get(value)?
+ .to_owned(),
+ )
}
// Retrieve the value of a setting by name
@@ -443,7 +448,7 @@ pub fn setting(req: &Request, name: &str) -> String {
// Detect and redirect in the event of a random subreddit
pub async fn catch_random(sub: &str, additional: &str) -> Result, String> {
if (sub == "random" || sub == "randnsfw") && !sub.contains('+') {
- let new_sub = json(format!("/r/{}/about.json?raw_json=1", sub)).await?["data"]["display_name"]
+ let new_sub = json(format!("/r/{}/about.json?raw_json=1", sub), false).await?["data"]["display_name"]
.as_str()
.unwrap_or_default()
.to_string();
diff --git a/templates/wall.html b/templates/wall.html
new file mode 100644
index 0000000..309dac2
--- /dev/null
+++ b/templates/wall.html
@@ -0,0 +1,13 @@
+{% extends "base.html" %}
+{% block title %}{{ msg }}{% endblock %}
+{% block sortstyle %}{% endblock %}
+{% block content %}
+
+
{{ title }}
+
+
{{ msg }}
+
+
+{% endblock %}