chore: address PR feedback

Author: jcnelson

stackslib/src/net/api/getstackers.rs

@@ -121,7 +121,7 @@ impl HttpRequest for GetStackersRequestHandler {
     }
 
     fn path_regex(&self) -> Regex {
-        Regex::new(r#"^/v3/stacker_set/(?P<cycle_num>[0-9]{1,20})$"#).unwrap()
+        Regex::new(r#"^/v3/stacker_set/(?P<cycle_num>[0-9]{1,10})$"#).unwrap()
     }
 
     fn metrics_identifier(&self) -> &str {

stackslib/src/net/atlas/db.rs

@@ -494,8 +494,12 @@ impl AtlasDB {
         page_index: u32,
         block_id: &StacksBlockId,
     ) -> Result<Vec<bool>, db_error> {
-        let min = page_index * AttachmentInstance::ATTACHMENTS_INV_PAGE_SIZE;
-        let max = min + AttachmentInstance::ATTACHMENTS_INV_PAGE_SIZE;
+        let min = page_index
+            .checked_mul(AttachmentInstance::ATTACHMENTS_INV_PAGE_SIZE)
+            .ok_or(db_error::Overflow)?;
+        let max = min
+            .checked_add(AttachmentInstance::ATTACHMENTS_INV_PAGE_SIZE)
+            .ok_or(db_error::Overflow)?;
         let qry = "SELECT attachment_index, is_available FROM attachment_instances WHERE attachment_index >= ?1 AND attachment_index < ?2 AND index_block_hash = ?3 ORDER BY attachment_index ASC";
         let args = params![min, max, block_id,];
         let rows = query_rows::<(u32, u32), _>(&self.conn, &qry, args)?;

stackslib/src/net/httpcore.rs

@@ -1686,17 +1686,17 @@ impl ProtocolFamily for StacksHttp {
                             &req.preamble().verb,
                             &decoded_path
                         )))?;
-                    handler_index
+                    Some(handler_index)
                 } else {
-                    0
+                    None
                 };
 
                 req.send(fd)?;
 
                 // remember this so we'll know how to decode the response.
                 // The next preamble and message we'll read _must be_ a response!
-                if !self.allow_arbitrary_response {
-                    self.request_handler_index = Some(handler_index);
+                if handler_index.is_some() {
+                    self.request_handler_index = handler_index;
                 }
                 Ok(())
             }
@@ -1768,14 +1768,10 @@ pub fn decode_request_path(path: &str) -> Result<(String, String), NetError> {
 
 /// Convert a NetError into an io::Error if appropriate.
 fn handle_net_error(e: NetError, msg: &str) -> io::Error {
-    if let NetError::ReadError(ioe) = e {
-        ioe
-    } else if let NetError::WriteError(ioe) = e {
-        ioe
-    } else if let NetError::RecvTimeout = e {
-        io::Error::new(io::ErrorKind::WouldBlock, "recv timeout")
-    } else {
-        io::Error::new(io::ErrorKind::Other, format!("{}: {:?}", &e, msg).as_str())
+    match e {
+        NetError::ReadError(ioe) | NetError::WriteError(ioe) => ioe,
+        NetError::RecvTimeout => io::Error::new(io::ErrorKind::WouldBlock, "recv timeout"),
+        _ => io::Error::new(io::ErrorKind::Other, format!("{}: {:?}", &e, msg).as_str()),
     }
 }
 
@@ -1911,8 +1907,7 @@ pub fn send_http_request(
     // and dispatched any new messages to the request handle.  If so, then extract the message and
     // check that it's a well-formed HTTP response.
     debug!("send_request(receiving data)");
-    let response;
-    loop {
+    let response = loop {
         // get back the reply
         debug!("send_request(receiving data): try to receive data");
         match connection.recv_data(&mut stream) {
@@ -1932,18 +1927,15 @@ pub fn send_http_request(
         debug!("send_request(receiving data): try receive response");
         let rh = match request_handle.try_recv() {
             Ok(resp) => {
-                response = resp;
-                break;
+                break resp;
+            }
+            Err(Ok(handle)) => handle,
+            Err(Err(e)) => {
+                return Err(handle_net_error(
+                    e,
+                    "Failed to receive message after socket has been drained",
+                ));
             }
-            Err(e) => match e {
-                Ok(handle) => handle,
-                Err(e) => {
-                    return Err(handle_net_error(
-                        e,
-                        "Failed to receive message after socket has been drained",
-                    ));
-                }
-            },
         };
         request_handle = rh;
 
@@ -1953,7 +1945,7 @@ pub fn send_http_request(
                 "Timed out while receiving request",
             ));
         }
-    }
+    };
 
     // Step 5: decode the HTTP message and return it if it's not an error.
     let response_data = match response {

testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs

@@ -1,4 +1,19 @@
-use std::convert::From;
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 use std::io::Cursor;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;