http: add AnnounceResponse.warning_message; set in http_private

aquatic_http/src/workers/request.rs

@@ -337,6 +337,7 @@ pub fn handle_announce_request(
                 announce_interval: config.protocol.peer_announce_interval,
                 peers: ResponsePeerListV4(response_peers),
                 peers6: ResponsePeerListV6(vec![]),
+                warning_message: None,
             };
 
             response
@@ -366,6 +367,7 @@ pub fn handle_announce_request(
                 announce_interval: config.protocol.peer_announce_interval,
                 peers: ResponsePeerListV4(vec![]),
                 peers6: ResponsePeerListV6(response_peers),
+                warning_message: None,
             };
 
             response

aquatic_http_private/src/workers/socket/db.rs

@@ -64,14 +64,14 @@ pub async fn validate_announce_request(
     user_agent: Option<String>,
     user_token: String,
     request: AnnounceRequest,
-) -> Result<ValidatedAnnounceRequest, FailureResponse> {
+) -> Result<(ValidatedAnnounceRequest, Option<String>), FailureResponse> {
     let parameters =
         AnnounceProcedureParameters::new(source_addr, user_agent, user_token, &request);
 
     match call_announce_procedure(pool, parameters).await {
         Ok(results) => {
             if results.announce_allowed {
-                Ok(ValidatedAnnounceRequest(request))
+                Ok((ValidatedAnnounceRequest(request), results.warning_message))
             } else {
                 Err(FailureResponse::new(
                     results

aquatic_http_private/src/workers/socket/routes.rs

@@ -40,7 +40,7 @@ pub async fn announce(
 
     let source_addr = CanonicalSocketAddr::new(source_addr);
 
-    let validated_request =
+    let (validated_request, opt_warning_message) =
         db::validate_announce_request(&pool, source_addr, opt_user_agent, user_token, request)
             .await
             .map_err(|r| create_response(Response::Failure(r)))?;
@@ -50,10 +50,14 @@ pub async fn announce(
         .await
         .map_err(|err| internal_error(format!("Sending request over channel failed: {:#}", err)))?;
 
-    let response = response_receiver.await.map_err(|err| {
+    let mut response = response_receiver.await.map_err(|err| {
         internal_error(format!("Receiving response over channel failed: {:#}", err))
     })?;
 
+    if let Response::Announce(ref mut r) = response {
+        r.warning_message = opt_warning_message;
+    }
+
     Ok(create_response(response))
 }
 

aquatic_http_protocol/benches/bench_announce_response_to_bytes.rs

@@ -21,6 +21,7 @@ pub fn bench(c: &mut Criterion) {
         incomplete: 500,
         peers: ResponsePeerListV4(peers),
         peers6: ResponsePeerListV6(Vec::new()),
+        warning_message: None,
     };
 
     let response = Response::Announce(announce_response);

aquatic_http_protocol/src/response.rs

@@ -51,6 +51,8 @@ pub struct AnnounceResponse {
     pub peers: ResponsePeerListV4,
     #[serde(default)]
     pub peers6: ResponsePeerListV6,
+    #[serde(rename = "warning message")]
+    pub warning_message: Option<String>,
 }
 
 impl AnnounceResponse {
@@ -95,6 +97,17 @@ impl AnnounceResponse {
         }
         bytes_written += output.write(b"e")?;
 
+        if let Some(ref warning_message) = self.warning_message {
+            let message_bytes = warning_message.as_bytes();
+
+            bytes_written += output.write(b"d15:warning message")?;
+            bytes_written +=
+                output.write(itoa::Buffer::new().format(message_bytes.len()).as_bytes())?;
+            bytes_written += output.write(b":")?;
+            bytes_written += output.write(message_bytes)?;
+            bytes_written += output.write(b"e")?;
+        }
+
         Ok(bytes_written)
     }
 }
@@ -232,6 +245,7 @@ impl quickcheck::Arbitrary for AnnounceResponse {
             incomplete: usize::arbitrary(g),
             peers: ResponsePeerListV4::arbitrary(g),
             peers6: ResponsePeerListV6::arbitrary(g),
+            warning_message: quickcheck::Arbitrary::arbitrary(g),
         }
     }
 }