fix: send unrecognized error on wrong http methods

src/api/appservice_server.rs

@@ -55,7 +55,9 @@ where
         Err(e) => {
             warn!(
                 "Could not send request to appservice {:?} at {}: {}",
-                registration.get("id"), destination, e
+                registration.get("id"),
+                destination,
+                e
             );
             return Err(e.into());
         }

src/api/client_server/keys.rs

@@ -443,7 +443,7 @@ pub(crate) async fn claim_keys_helper(
     let mut futures: FuturesUnordered<_> = get_over_federation
         .into_iter()
         .map(|(server, vec)| async move {
-        let mut one_time_keys_input_fed = BTreeMap::new();
+            let mut one_time_keys_input_fed = BTreeMap::new();
             for (user_id, keys) in vec {
                 one_time_keys_input_fed.insert(user_id.clone(), keys.clone());
             }
@@ -459,7 +459,8 @@ pub(crate) async fn claim_keys_helper(
                     )
                     .await,
             )
-        }).collect();
+        })
+        .collect();
 
     while let Some((server, response)) = futures.next().await {
         match response {

src/api/client_server/read_marker.rs

@@ -1,7 +1,10 @@
 use crate::{services, Error, Result, Ruma};
 use ruma::{
     api::client::{error::ErrorKind, read_marker::set_read_marker, receipt::create_receipt},
-    events::{receipt::{ReceiptType, ReceiptThread}, RoomAccountDataEventType},
+    events::{
+        receipt::{ReceiptThread, ReceiptType},
+        RoomAccountDataEventType,
+    },
     MilliSecondsSinceUnixEpoch,
 };
 use std::collections::BTreeMap;

src/api/server_server.rs

@@ -305,9 +305,12 @@ where
             }
         }
         Err(e) => {
-            warn!("Could not send request to {} at {}: {}", destination, actual_destination_str, e);
+            warn!(
+                "Could not send request to {} at {}: {}",
+                destination, actual_destination_str, e
+            );
             Err(e.into())
-        },
+        }
     }
 }
 

src/database/key_value/sending.rs

@@ -6,7 +6,7 @@ use crate::{
         self,
         sending::{OutgoingKind, SendingEventType},
     },
-    utils, Error, Result, services,
+    services, utils, Error, Result,
 };
 
 impl service::sending::Data for KeyValueDatabase {

src/main.rs

@@ -145,6 +145,7 @@ async fn run_server() -> io::Result<()> {
             }),
         )
         .compression()
+        .layer(axum::middleware::from_fn(unrecognized_method))
         .layer(
             CorsLayer::new()
                 .allow_origin(cors::Any)
@@ -187,6 +188,22 @@ async fn run_server() -> io::Result<()> {
     Ok(())
 }
 
+async fn unrecognized_method<B>(
+    req: axum::http::Request<B>,
+    next: axum::middleware::Next<B>,
+) -> std::result::Result<axum::response::Response, axum::http::StatusCode> {
+    let method = req.method().clone();
+    let uri = req.uri().clone();
+    let inner = next.run(req).await;
+    if inner.status() == axum::http::StatusCode::METHOD_NOT_ALLOWED {
+        warn!("Method not allowed: {method} {uri}");
+        return Ok(
+            Error::BadRequest(ErrorKind::Unrecognized, "Unrecognized request").into_response(),
+        );
+    }
+    Ok(inner)
+}
+
 fn routes() -> Router {
     Router::new()
         .ruma_route(client_server::get_supported_versions_route)
@@ -386,12 +403,16 @@ async fn shutdown_signal(handle: ServerHandle) {
     handle.graceful_shutdown(Some(Duration::from_secs(30)));
 }
 
-async fn not_found(_uri: Uri) -> impl IntoResponse {
+async fn not_found(uri: Uri) -> impl IntoResponse {
+    warn!("Not found: {uri}");
     Error::BadRequest(ErrorKind::Unrecognized, "Unrecognized request")
 }
 
 async fn initial_sync(_uri: Uri) -> impl IntoResponse {
-    Error::BadRequest(ErrorKind::GuestAccessForbidden, "Guest access not implemented")
+    Error::BadRequest(
+        ErrorKind::GuestAccessForbidden,
+        "Guest access not implemented",
+    )
 }
 
 trait RouterExt {

src/service/pusher/mod.rs

@@ -131,7 +131,7 @@ impl Service {
             Err(e) => {
                 warn!("Could not send request to pusher {}: {}", destination, e);
                 Err(e.into())
-            },
+            }
         }
     }