Fix some linter warnings

3 files changed, 37 insertions, 37 deletions

diff --git a/src/lib.rs b/src/lib.rs
index 842dcb9..d9feeaf 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -270,7 +270,7 @@ impl Tftp {
         if options.is_empty() {
             if !ackwait {
                 /* it's a WRQ, send normal ack to start transfer */
-                self.send_ack(&sock, 0)?;
+                self.send_ack(sock, 0)?;
             }
             return Ok(());
         }
@@ -287,7 +287,7 @@ impl Tftp {
             if !ackwait {
                 return Ok(());
             }
-            match self.wait_for_ack(&sock, 0) {
+            match self.wait_for_ack(sock, 0) {
                 Ok(true) => return Ok(()),
                 Ok(false) => continue,
                 Err(e) => return Err(e),
@@ -304,14 +304,14 @@ impl Tftp {
             let val = val.to_lowercase();
             match key.to_lowercase().as_str() {
                 "blksize" => match val.parse() {
-                    Ok(b) if b >= 8 && b <= 65464 => {
+                    Ok(b) if (8..=65464).contains(&b) => {
                         self.options.blksize = b;
                         true
                     }
                     _ => false,
                 },
                 "blksize2" => match val.parse() {
-                    Ok(b) if b >= 8 && b <= 32768 => {
+                    Ok(b) if (8..=32768).contains(&b) => {
                         /* select 2^x lower or equal the requested size */
                         self.options.blksize = blksize2(b);
                         true
@@ -431,7 +431,7 @@ impl Tftp {
             let mut len = match self.read_exact(&mut reader, &mut filebuf) {
                 Ok(n) => n,
                 Err(err) => {
-                    self.send_error(&socket, 0, "File reading error")?;
+                    self.send_error(socket, 0, "File reading error")?;
                     return Err(err);
                 }
             };
@@ -462,7 +462,7 @@ impl Tftp {
                 /* try a couple of times to send data, in case of timeouts
                    or re-ack of previous data */
                 socket.send(&sendbuf)?;
-                match self.wait_for_ack(&socket, block_nr) {
+                match self.wait_for_ack(socket, block_nr) {
                     Ok(true) => {
                         acked = true;
                         break;
@@ -507,7 +507,7 @@ impl Tftp {
                     Ok(n) => n,
                     Err(ref error) if [io::ErrorKind::WouldBlock, io::ErrorKind::TimedOut].contains(&error.kind()) => {
                         /* re-ack previous and try to recv again */
-                        self.send_ack(&sock, block_nr - 1)?;
+                        self.send_ack(sock, block_nr - 1)?;
                         continue;
                     }
                     Err(err) => return Err(err),
@@ -526,7 +526,7 @@ impl Tftp {
             };
             if u16::from_be_bytes([buf[2], buf[3]]) != block_nr {
                 /* already received or packets were missed, re-acknowledge */
-                self.send_ack(&sock, block_nr - 1)?;
+                self.send_ack(sock, block_nr - 1)?;
                 continue;
             }
 
@@ -546,7 +546,7 @@ impl Tftp {
                 prog_update = cb(transferred, tsize, prog_update);
             }
 
-            self.send_ack(&sock, block_nr)?;
+            self.send_ack(sock, block_nr)?;
             block_nr = block_nr.wrapping_add(1);
 
             if len < 4 + self.options.blksize {
diff --git a/src/tftpc.rs b/src/tftpc.rs
index d47468f..453837c 100644
--- a/src/tftpc.rs
+++ b/src/tftpc.rs
@@ -74,7 +74,7 @@ impl Tftpc {
         let (len, remote) = sock.recv_from(&mut buf).ok()?;
 
         let mut options = self.tftp.parse_options(&buf[2..len]);
-        self.tftp.init_tftp_options(&sock, &mut options).ok()?;
+        self.tftp.init_tftp_options(sock, &mut options).ok()?;
 
         Some(remote)
     }
@@ -144,10 +144,10 @@ impl Tftpc {
         let mut remote = None;
         for _ in 1..3 {
             sock.send_to(&buf, self.conf.remote)?;
-            remote = self.wait_for_option_ack(&sock);
+            remote = self.wait_for_option_ack(sock);
             if remote.is_none() {
                 /* for WRQ either OACK or ACK is replied */
-                remote = self.wait_for_response(&sock, rtftp::Opcode::ACK, 0, None)?;
+                remote = self.wait_for_response(sock, rtftp::Opcode::ACK, 0, None)?;
             }
             if remote.is_some() {
                 break;
@@ -159,11 +159,11 @@ impl Tftpc {
             None => return Err(io::Error::new(io::ErrorKind::TimedOut, "No response from server")),
         }
 
-        match self.tftp.send_file(&sock, &mut file) {
+        match self.tftp.send_file(sock, &mut file) {
             Ok(_) => Ok(format!("Sent {} to {}.", self.conf.filename.display(), self.conf.remote)),
             Err(err) => {
                 let error = format!("Sending {} to {} failed ({}).", self.conf.filename.display(), self.conf.remote, err);
-                self.tftp.send_error(&sock, 0, "Sending error")?;
+                self.tftp.send_error(sock, 0, "Sending error")?;
                 Err(io::Error::new(err.kind(), error))
             }
         }
@@ -181,12 +181,12 @@ impl Tftpc {
         let mut remote = None;
         for _ in 1..3 {
             sock.send_to(&buf, self.conf.remote)?;
-            let oack_remote = self.wait_for_option_ack(&sock);
+            let oack_remote = self.wait_for_option_ack(sock);
             if let Some(r) = oack_remote {
                 /* for RRQ the received OACKs need to be acked */
-                self.tftp.send_ack_to(&sock, r, 0)?;
+                self.tftp.send_ack_to(sock, r, 0)?;
             }
-            remote = self.wait_for_response(&sock, rtftp::Opcode::DATA, 1, oack_remote)?;
+            remote = self.wait_for_response(sock, rtftp::Opcode::DATA, 1, oack_remote)?;
             if remote.is_some() {
                 break;
             }
@@ -197,11 +197,11 @@ impl Tftpc {
             None => return Err(io::Error::new(io::ErrorKind::TimedOut, "No response from server")),
         }
 
-        match self.tftp.recv_file(&sock, &mut file) {
+        match self.tftp.recv_file(sock, &mut file) {
             Ok(_) => Ok(format!("Received {} from {}.", self.conf.filename.display(), self.conf.remote)),
             Err(err) => {
                 let error = format!("Receiving {} from {} failed ({}).", self.conf.filename.display(), self.conf.remote, err);
-                self.tftp.send_error(&sock, 0, "Receiving error")?;
+                self.tftp.send_error(sock, 0, "Receiving error")?;
                 Err(std::io::Error::new(err.kind(), error))
             }
         }
diff --git a/src/tftpd.rs b/src/tftpd.rs
index f056a74..e9fc6b6 100644
--- a/src/tftpd.rs
+++ b/src/tftpd.rs
@@ -84,13 +84,13 @@ impl Tftpd {
 
     fn handle_wrq(&mut self, socket: &UdpSocket, cl: &SocketAddr, buf: &[u8]) -> Result<String, io::Error> {
         let (filename, mode, mut options) = self.tftp.parse_file_mode_options(buf)?;
-        self.tftp.init_tftp_options(&socket, &mut options)?;
+        self.tftp.init_tftp_options(socket, &mut options)?;
 
         match mode.as_ref() {
             "octet" => self.tftp.set_mode(rtftp::Mode::OCTET),
             "netascii" => self.tftp.set_mode(rtftp::Mode::NETASCII),
             _ => {
-                self.tftp.send_error(&socket, 0, "Unsupported mode")?;
+                self.tftp.send_error(socket, 0, "Unsupported mode")?;
                 return Err(io::Error::new(io::ErrorKind::Other, "unsupported mode"));
             }
         }
@@ -99,7 +99,7 @@ impl Tftpd {
             Some(p) => p,
             None => {
                 let err = format!("Receiving {} from {} failed (permission check failed).", filename.display(), cl);
-                self.tftp.send_error(&socket, 2, "Permission denied")?;
+                self.tftp.send_error(socket, 2, "Permission denied")?;
                 return Err(io::Error::new(io::ErrorKind::PermissionDenied, err));
             }
         };
@@ -108,22 +108,22 @@ impl Tftpd {
             Ok(f) => f,
             Err(ref err) if err.kind() == io::ErrorKind::AlreadyExists => {
                 let error = format!("Receiving {} from {} failed ({}).", path.display(), cl, err);
-                self.tftp.send_error(&socket, 6, "File already exists")?;
+                self.tftp.send_error(socket, 6, "File already exists")?;
                 return Err(io::Error::new(err.kind(), error));
             }
             Err(err) => {
                 let error = format!("Receiving {} from {} failed ({}).", path.display(), cl, err);
-                self.tftp.send_error(&socket, 6, "Permission denied")?;
+                self.tftp.send_error(socket, 6, "Permission denied")?;
                 return Err(io::Error::new(io::ErrorKind::PermissionDenied, error));
             }
         };
 
-        self.tftp.ack_options(&socket, &options, false)?;
-        match self.tftp.recv_file(&socket, &mut file) {
+        self.tftp.ack_options(socket, &options, false)?;
+        match self.tftp.recv_file(socket, &mut file) {
             Ok(_) => Ok(format!("Received {} from {}.", path.display(), cl)),
             Err(ref err) => {
                 let error = format!("Receiving {} from {} failed ({}).", path.display(), cl, err);
-                self.tftp.send_error(&socket, 0, "Receiving error")?;
+                self.tftp.send_error(socket, 0, "Receiving error")?;
                 Err(io::Error::new(err.kind(), error))
             }
         }
@@ -131,13 +131,13 @@ impl Tftpd {
 
     fn handle_rrq(&mut self, socket: &UdpSocket, cl: &SocketAddr, buf: &[u8]) -> Result<String, io::Error> {
         let (filename, mode, mut options) = self.tftp.parse_file_mode_options(buf)?;
-        self.tftp.init_tftp_options(&socket, &mut options)?;
+        self.tftp.init_tftp_options(socket, &mut options)?;
 
         match mode.as_ref() {
             "octet" => self.tftp.set_mode(rtftp::Mode::OCTET),
             "netascii" => self.tftp.set_mode(rtftp::Mode::NETASCII),
             _ => {
-                self.tftp.send_error(&socket, 0, "Unsupported mode")?;
+                self.tftp.send_error(socket, 0, "Unsupported mode")?;
                 return Err(io::Error::new(io::ErrorKind::Other, "unsupported mode"));
             }
         }
@@ -146,7 +146,7 @@ impl Tftpd {
             Some(p) => p,
             None => {
                 let err = format!("Sending {} to {} failed (permission check failed).", filename.display(), cl);
-                self.tftp.send_error(&socket, 2, "Permission denied")?;
+                self.tftp.send_error(socket, 2, "Permission denied")?;
                 return Err(io::Error::new(io::ErrorKind::PermissionDenied, err));
             }
         };
@@ -155,25 +155,25 @@ impl Tftpd {
             Ok(f) => f,
             Err(ref error) if error.kind() == io::ErrorKind::NotFound => {
                 let err = format!("Sending {} to {} failed ({}).", path.display(), cl, error.to_string());
-                self.tftp.send_error(&socket, 1, "File not found")?;
+                self.tftp.send_error(socket, 1, "File not found")?;
                 return Err(io::Error::new(io::ErrorKind::NotFound, err));
             }
             Err(error) => {
                 let err = format!("Sending {} to {} failed ({}).", path.display(), cl, error.to_string());
-                self.tftp.send_error(&socket, 2, "Permission denied")?;
+                self.tftp.send_error(socket, 2, "Permission denied")?;
                 return Err(io::Error::new(io::ErrorKind::PermissionDenied, err));
             }
         };
         if !file.metadata()?.is_file() {
-            self.tftp.send_error(&socket, 1, "File not found")?;
+            self.tftp.send_error(socket, 1, "File not found")?;
             return Err(io::Error::new(io::ErrorKind::NotFound, "file not found"));
         }
 
         if let Some(opt) = options.get_mut("tsize") {
             *opt = self.tftp.transfersize(&mut file)?.to_string();
         }
-        self.tftp.ack_options(&socket, &options, true)?;
-        match self.tftp.send_file(&socket, &mut file) {
+        self.tftp.ack_options(socket, &options, true)?;
+        match self.tftp.send_file(socket, &mut file) {
             Ok(_) => Ok(format!("Sent {} to {}.", path.display(), cl)),
             Err(err) => {
                 let error = format!("Sending {} to {} failed ({}).", path.display(), cl, err.to_string());
@@ -198,7 +198,7 @@ impl Tftpd {
                     self.tftp.send_error(&socket, 4, "reading not allowed")?;
                     Err(io::Error::new(io::ErrorKind::Other, "unallowed mode"))
                 } else {
-                    self.handle_rrq(&socket, &cl, &buf[2..])
+                    self.handle_rrq(&socket, cl, &buf[2..])
                 }
             }
             o if o == rtftp::Opcode::WRQ as u16 => {
@@ -206,7 +206,7 @@ impl Tftpd {
                     self.tftp.send_error(&socket, 4, "writing not allowed")?;
                     Err(io::Error::new(io::ErrorKind::Other, "unallowed mode"))
                 } else {
-                    self.handle_wrq(&socket, &cl, &buf[2..])
+                    self.handle_wrq(&socket, cl, &buf[2..])
                 }
             }
             o if o == rtftp::Opcode::ERROR as u16 => Ok(format!("Received ERROR from {}", cl)),