feat(server): add an endpoint for retrieving a list of files

Cargo.toml

@@ -52,6 +52,7 @@ shuttle-actix-web = { version = "0.21.0", optional = true }
 shuttle-runtime = { version = "0.21.0", optional = true }
 shuttle-static-folder = { version = "0.21.0", optional = true }
 tokio = { version = "1.29.1", optional = true }
+uts2ts = "0.3.0"
 
 [dependencies.config]
 version = "0.13.3"

README.md

@@ -257,6 +257,17 @@ You can also set multiple auth tokens via the array field `[server].auth_tokens`
 
 See [config.toml](./config.toml) for configuration options.
 
+### List endpoint
+
+Set `expose_list` to true in [config.toml](./config.toml) to be able to retrieve a JSON formatted list of files in your uploads directory. This will not include oneshot files, oneshot urls, or urls. 
+
+```sh
+$ curl "http://<server_address>/list"
+
+[{"expires_at":null,"file_name":"accepted-cicada.txt","file_size":241}]
+```
+This route will require an `AUTH_TOKEN` if one is set.
+
 #### HTML Form
 
 It is possible to use an HTML form for uploading files. To do so, you need to update two fields in your `config.toml`:

config.toml

@@ -9,6 +9,7 @@ max_content_length = "10MB"
 upload_path = "./upload"
 timeout = "30s"
 expose_version = false
+expose_list = false
 #auth_tokens = [
 #  "super_secret_token1",
 #  "super_secret_token2",

src/config.rs

@@ -58,6 +58,8 @@ pub struct ServerConfig {
     /// Landing page content-type.
     #[deprecated(note = "use the [landing_page] table")]
     pub landing_page_content_type: Option<String>,
+    /// Path of the JSON index.
+    pub expose_list: Option<bool>,
 }
 
 /// Landing page configuration.

src/server.rs

@@ -12,11 +12,13 @@ use awc::Client;
 use byte_unit::Byte;
 use futures_util::stream::StreamExt;
 use mime::TEXT_PLAIN_UTF_8;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
 use std::env;
 use std::fs;
+use std::path::Path;
 use std::sync::RwLock;
+use uts2ts;
 
 /// Shows the landing page.
 #[get("/")]
@@ -283,10 +285,78 @@ async fn upload(
     Ok(HttpResponse::Ok().body(urls.join("")))
 }
 
+/// File entry item for list endpoint.
+#[derive(Serialize, Deserialize)]
+pub struct ListItem {
+    /// Uploaded file name.
+    pub filename: String,
+    /// Size of the file in bytes.
+    pub filesize: u64,
+    /// ISO8601 formatted date-time string of the expiration timestamp if one exists for this file.
+    pub expires_at: Option<String>,
+}
+
+/// Returns the list of files.
+#[get("/list")]
+async fn list(
+    request: HttpRequest,
+    config: web::Data<RwLock<Config>>,
+) -> Result<HttpResponse, Error> {
+    let config = config
+        .read()
+        .map_err(|_| error::ErrorInternalServerError("cannot acquire config"))?
+        .clone();
+    let connection = request.connection_info().clone();
+    let host = connection.realip_remote_addr().unwrap_or("unknown host");
+
+    let tokens = config.get_tokens();
+    auth::check(host, request.headers(), tokens)?;
+
+    if !config.server.expose_list.unwrap_or(false) {
+        log::warn!("server is not configured to expose list endpoint");
+        Err(error::ErrorForbidden("endpoint is not exposed\n"))?;
+    }
+    let entries: Vec<ListItem> = fs::read_dir(config.server.upload_path)?
+        .filter_map(|entry| {
+            entry.ok().and_then(|e| {
+                let metadata = fs::metadata(e.path()).expect("Failed to retrieve metadata");
+
+                if metadata.is_dir() {
+                    return None;
+                }
+
+                let filename = e.file_name().into_string().ok()?;
+                let extension: Option<i64> = Path::new(&filename)
+                    .extension()
+                    .and_then(|ext| ext.to_str())
+                    .and_then(|v| v.parse().ok());
+
+                let mut expires_at = None;
+
+                if let Some(expiration) = extension {
+                    let seconds = expiration / 1000;
+                    let timestamp = uts2ts::uts2ts(seconds);
+
+                    expires_at = Some(timestamp.as_string());
+                }
+
+                Some(ListItem {
+                    filename,
+                    filesize: metadata.len(),
+                    expires_at,
+                })
+            })
+        })
+        .collect();
+
+    Ok(HttpResponse::Ok().json(entries))
+}
+
 /// Configures the server routes.
 pub fn configure_routes(cfg: &mut web::ServiceConfig) {
     cfg.service(index)
         .service(version)
+        .service(list)
         .service(serve)
         .service(upload)
         .route("", web::head().to(HttpResponse::MethodNotAllowed));
@@ -513,6 +583,45 @@ mod tests {
         Ok(())
     }
 
+    #[actix_web::test]
+    async fn test_list() -> Result<(), Error> {
+        let mut config = Config::default();
+        config.server.expose_list = Some(true);
+
+        let test_upload_dir = "test_upload";
+        fs::create_dir(test_upload_dir)?;
+        config.server.upload_path = PathBuf::from(test_upload_dir);
+
+        let app = test::init_service(
+            App::new()
+                .app_data(Data::new(RwLock::new(config)))
+                .app_data(Data::new(Client::default()))
+                .configure(configure_routes),
+        )
+        .await;
+
+        let filename = "test_file.txt";
+        let timestamp = util::get_system_time()?.as_secs().to_string();
+        test::call_service(
+            &app,
+            get_multipart_request(&timestamp, "file", filename).to_request(),
+        )
+        .await;
+
+        let request = TestRequest::default()
+            .insert_header(("content-type", "text/plain"))
+            .uri("/list")
+            .to_request();
+        let result: Vec<ListItem> = test::call_and_read_body_json(&app, request).await;
+
+        assert_eq!(result.len(), 1);
+        assert_eq!(result.first().expect("json object").filename, filename);
+
+        fs::remove_dir_all(test_upload_dir)?;
+
+        Ok(())
+    }
+
     #[actix_web::test]
     async fn test_auth() -> Result<(), Error> {
         let mut config = Config::default();