mirrors/redlib
1
0
Fork 0
mirror of https://github.com/redlib-org/redlib.git synced 2025-04-04 13:37:40 +03:00
Code Issues Projects Releases Packages Wiki Activity

Split subscriptions and filters cookies into multiple cookies and make old cookies properly delete

Browse source
This commit is contained in:
Butter Cat 2024-10-11 21:17:33 -04:00
parent f4a457e529
commit 718bafe650
No known key found for this signature in database
GPG key ID: FF37BE4FDDB74419
3 changed files with 137 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

11
src/server.rs
View file

@ -24,7 +24,7 @@ use std::{
str::{from_utf8, Split}, str::{from_utf8, Split},
string::ToString, string::ToString,
}; };
use time::Duration; use time::OffsetDateTime;
use crate::dbg_msg; use crate::dbg_msg;
@ -169,10 +169,11 @@ impl ResponseExt for Response<Body> {
} }
fn remove_cookie(&mut self, name: String) { fn remove_cookie(&mut self, name: String) {
let mut cookie = Cookie::from(name); let removal_cookie = Cookie::build(name)
cookie.set_path("/"); .path("/")
cookie.set_max_age(Duration::seconds(1)); .http_only(true)
if let Ok(val) = header::HeaderValue::from_str(&cookie.to_string()) { .expires(OffsetDateTime::now_utc());
if let Ok(val) = header::HeaderValue::from_str(&removal_cookie.to_string()) {
self.headers_mut().append("Set-Cookie", val); self.headers_mut().append("Set-Cookie", val);
} }
} }

94
src/subreddit.rs
View file

@ -6,6 +6,7 @@ use crate::utils::{
use crate::{client::json, server::ResponseExt, RequestExt}; use crate::{client::json, server::ResponseExt, RequestExt};
use cookie::Cookie; use cookie::Cookie;
use hyper::{Body, Request, Response}; use hyper::{Body, Request, Response};
use rinja::filters::format;
use rinja::Template; use rinja::Template;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
@ -209,6 +210,39 @@ pub fn can_access_quarantine(req: &Request<Body>, sub: &str) -> bool {
setting(req, &format!("allow_quaran_{}", sub.to_lowercase())).parse().unwrap_or_default() setting(req, &format!("allow_quaran_{}", sub.to_lowercase())).parse().unwrap_or_default()
} }
// Join items in chunks of 3500 bytes in length for cookies
fn join_until_size_limit<T: std::fmt::Display>(vec: &[T]) -> Vec<std::string::String> {
let mut result = Vec::new();
let mut list = String::new();
let mut current_size = 0;
for item in vec {
// Size in bytes
let item_size = item.to_string().len();
// Use 3500 bytes to leave us some headroom because the name and options of the cookie count towards the 4096 byte cap
if current_size + item_size > 3500 {
// Push current list to result vector
result.push(list);
// Do a reset of the variables required to continue
list = String::new();
current_size = 0;
}
// Add separator if not the first item
if !list.is_empty() {
list.push_str("+");
}
// Add current item to list
list.push_str(&item.to_string());
current_size += item_size;
}
// Make sure to push whatever the remaining subreddits are there into the result vector
result.push(list);
// Return resulting vector
result
}
// Sub, filter, unfilter, or unsub by setting subscription cookie using response "Set-Cookie" header // Sub, filter, unfilter, or unsub by setting subscription cookie using response "Set-Cookie" header
pub async fn subscriptions_filters(req: Request<Body>) -> Result<Response<Body>, String> { pub async fn subscriptions_filters(req: Request<Body>) -> Result<Response<Body>, String> {
let sub = req.param("sub").unwrap_or_default(); let sub = req.param("sub").unwrap_or_default();
@ -303,26 +337,54 @@ pub async fn subscriptions_filters(req: Request<Body>) -> Result<Response<Body>,
// Delete cookie if empty, else set // Delete cookie if empty, else set
if sub_list.is_empty() { if sub_list.is_empty() {
response.remove_cookie("subscriptions".to_string()); // Start with first subcriptions cookie
let mut subcriptions_number = 1;
// While whatever subcriptionsNUMBER cookie we're looking at has a value
while req.cookie(&format!("subcriptions{}", subcriptions_number)).is_some() {
// Remove that subcriptions cookie
response.remove_cookie(format!("subcriptions{}", subcriptions_number));
// Increment subcriptions cookie number
subcriptions_number += 1;
}
} else { } else {
response.insert_cookie( let mut subcriptions_number = 1;
Cookie::build(("subscriptions", sub_list.join("+"))) for list in join_until_size_limit(&sub_list) {
.path("/") response.insert_cookie(
.http_only(true) Cookie::build((format!("subscriptions{}", subcriptions_number), list))
.expires(OffsetDateTime::now_utc() + Duration::weeks(52)) .path("/")
.into(), .http_only(true)
); .expires(OffsetDateTime::now_utc() + Duration::weeks(52))
.into(),
);
subcriptions_number += 1;
}
} }
if filters.is_empty() { if filters.is_empty() {
response.remove_cookie("filters".to_string()); // Start with first filters cookie
let mut filters_number = 1;
// While whatever filtersNUMBER cookie we're looking at has a value
while req.cookie(&format!("filters{}", filters_number)).is_some() {
// Remove that filters cookie
response.remove_cookie(format!("filters{}", filters_number));
// Increment filters cookie number
filters_number += 1;
}
} else { } else {
response.insert_cookie( let mut filters_number = 1;
Cookie::build(("filters", filters.join("+"))) for list in join_until_size_limit(&filters) {
.path("/") response.insert_cookie(
.http_only(true) Cookie::build((format!("filters{}", filters_number), list))
.expires(OffsetDateTime::now_utc() + Duration::weeks(52)) .path("/")
.into(), .http_only(true)
); .expires(OffsetDateTime::now_utc() + Duration::weeks(52))
.into(),
);
filters_number += 1;
}
} }
Ok(response) Ok(response)

65
src/utils.rs
View file

@ -9,6 +9,7 @@ use hyper::{Body, Request, Response};
use log::error; use log::error;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
use regex::Regex; use regex::Regex;
use rinja::filters::format;
use rinja::Template; use rinja::Template;
use rust_embed::RustEmbed; use rust_embed::RustEmbed;
use serde_json::Value; use serde_json::Value;
@ -798,18 +799,58 @@ pub fn param(path: &str, value: &str) -> Option<String> {
// Retrieve the value of a setting by name // Retrieve the value of a setting by name
pub fn setting(req: &Request<Body>, name: &str) -> String { pub fn setting(req: &Request<Body>, name: &str) -> String {
// Parse a cookie value from request // Parse a cookie value from request
req
.cookie(name) // If this was called with "subscriptions" and the "subscriptions1" cookie has a value
.unwrap_or_else(|| { if name == "subscriptions" && req.cookie("subscriptions1").is_some() {
// If there is no cookie for this setting, try receiving a default from the config // Create subscriptions string
if let Some(default) = get_setting(&format!("REDLIB_DEFAULT_{}", name.to_uppercase())) { let mut subscriptions = String::new();
Cookie::new(name, default)
} else { // Start with first subscription cookie
Cookie::from(name) let mut subscriptions_number = 1;
}
}) // While whatever subscriptionsNUMBER cookie we're looking at has a value
.value() while req.cookie(&format!("subscriptions{}", subscriptions_number)).is_some() {
.to_string() // Push whatever subscriptionsNUMBER cookie we're looking at into the subscriptions string
subscriptions.push_str(&req.cookie(&format!("subscriptions{}", subscriptions_number)).unwrap().value().to_string());
// Increment subscription cookie number
subscriptions_number += 1;
}
// Return the subscriptions cookies as one large string
subscriptions
} else if name == "filters" && req.cookie("filters1").is_some() { // If this was called with "filters" and the "filters1" cookie has a value
// Create filters string
let mut filters = String::new();
// Start with first filters cookie
let mut filters_number = 1;
// While whatever filtersNUMBER cookie we're looking at has a value
while req.cookie(&format!("filters{}", filters_number)).is_some() {
// Push whatever filtersNUMBER cookie we're looking at into the filters string
filters.push_str(&req.cookie(&format!("filters{}", filters_number)).unwrap().value().to_string());
// Increment filters cookie number
filters_number += 1;
}
// Return the filters cookies as one large string
filters
} else { // The above two still come to this if there was no existing value
req
.cookie(name)
.unwrap_or_else(|| {
// If there is no cookie for this setting, try receiving a default from the config
if let Some(default) = get_setting(&format!("REDLIB_DEFAULT_{}", name.to_uppercase())) {
Cookie::new(name, default)
} else {
Cookie::from(name)
}
})
.value()
.to_string()
}
} }
// Retrieve the value of a setting by name or the default value // Retrieve the value of a setting by name or the default value