Clean up clippy warnings

Author: stouset

sample/bin/sudo_approve

@@ -50,6 +50,10 @@ pair() {
     # (which causes a SIGPIPE to get sent). So the `kill` ensures the
     # subshell is killed without the user having to type something
     # additional that would cause the command to exit.
+    #
+    # FIXME: Technically, `echo` puts a secret value into an process
+    # argument list, which isn't great. However, the window for
+    # exploitation here is microscopic.
     { socat STDIO unix-connect:"${socket}"; kill $!; } < <(
         echo -n "${token}" ; cat -
     )

sudo_pair/src/errors.rs

@@ -20,7 +20,7 @@ pub(crate) enum ErrorKind {
 }
 
 impl ErrorKind {
-    fn as_str(&self) -> &str {
+    fn as_str(self) -> &'static str {
         match self {
             ErrorKind::CommunicationError => "couldn't establish communications with the pair",
             ErrorKind::SessionDeclined    => "pair declined the session",
@@ -51,14 +51,14 @@ impl Display for Error {
 impl Fail for Error {}
 
 impl From<ErrorKind> for Error {
-    fn from(kind: ErrorKind) -> Error {
-        Error::from(Context::new(kind))
+    fn from(kind: ErrorKind) -> Self {
+        Self::from(Context::new(kind))
     }
 }
 
 impl From<Context<ErrorKind>> for Error {
-    fn from(inner: Context<ErrorKind>) -> Error {
-        Error { inner: inner }
+    fn from(inner: Context<ErrorKind>) -> Self {
+        Self { inner }
     }
 }
 
@@ -68,8 +68,8 @@ impl From<Context<ErrorKind>> for Error {
 /// converted to an Unauthorized error.
 ///
 impl From<Error> for SudoPluginError {
-    fn from(error: Error) -> SudoPluginError {
-        SudoPluginError::with_chain(
+    fn from(error: Error) -> Self {
+        Self::with_chain(
             error.compat(),
             SudoPluginErrorKind::Unauthorized
         )
@@ -81,7 +81,7 @@ impl From<Error> for SudoPluginError {
 /// implicitly wrapped in a new `Error`.
 ///
 impl From<ErrorKind> for SudoPluginError {
-    fn from(kind: ErrorKind) -> SudoPluginError {
-        SudoPluginError::from(Error::from(kind))
+    fn from(kind: ErrorKind) -> Self {
+        Self::from(Error::from(kind))
     }
 }

sudo_pair/src/lib.rs

@@ -283,7 +283,13 @@ impl SudoPair {
         ).context(ErrorKind::CommunicationError)?;
 
         let mut response : [u8; 16] = [0; 16];
-        let _ = socket.read_exact(&mut response)
+
+        // TODO: read_exact will cause this process to block
+        // indefinitely (even on Ctrl-C) until the correct number of
+        // bytes are read; this won't happen in normal circumstances,
+        // but a bug in (or untimely exit of) the approval script can
+        // cause this process to hang and require being killed
+        socket.read_exact(&mut response)
             .context(ErrorKind::CommunicationError)?;
 
         // non-constant comparison is fine here since a comparison

sudo_pair/src/socket.rs

@@ -12,6 +12,11 @@
 // implied. See the License for the specific language governing
 // permissions and limitations under the License.
 
+// these warnings are unavoidable with names like `uid` and `gid`, and
+// such names are natural to use for this problem domain so should not
+// be avoided
+#![cfg_attr(feature="cargo-clippy", allow(similar_names))]
+
 use std::ffi::CString;
 use std::fs;
 use std::io::{Read, Write, Result, Error, ErrorKind};
@@ -30,7 +35,6 @@ pub(crate) struct Socket {
 }
 
 impl Socket {
-    #[cfg_attr(feature="cargo-clippy", allow(similar_names))]
     pub(crate) fn open<P: AsRef<Path>>(
         path: P,
         uid:  uid_t,

sudo_plugin/src/plugin/option_map.rs

@@ -68,6 +68,12 @@ impl OptionMap {
             // separators might not exist (e.g., in the case of parsing
             // plugin options; for this case, we use the full entry as
             // both the name of the key and its value
+            //
+            // indexing into an array can panic, but there's no cleaner
+            // way in rust to split a byte array on a delimiter, and
+            // the code above selects `sep` such that it's guaranteed to
+            // be within the slice
+            #[cfg_attr(feature = "cargo-clippy", allow(indexing_slicing))]
             let (k, v) = match sep {
                 Some(s) => { ( &bytes[..s], &bytes[s+1..] ) }
                 None    => { ( &bytes[..],  &bytes[..] ) }

sudo_plugin/src/plugin/settings.rs

@@ -199,6 +199,11 @@ pub struct NetAddr {
 impl FromSudoOption for NetAddr {
     type Err = AddrParseError;
 
+    // indexing into an array can panic, but there's no cleaner way in
+    // rust to split a byte array on a delimiter, and the code below
+    // selects the midpoint such that it's guaranteed to be within the
+    // slice
+    #[cfg_attr(feature = "cargo-clippy", allow(indexing_slicing))]
     fn from_sudo_option(s: &str) -> ::std::result::Result<Self, Self::Err> {
         let bytes = s.as_bytes();
         let mid   = bytes.iter()