refactor: fix warnings

kernel/libk/src/vfs/file/pipe.rs

@@ -6,7 +6,7 @@ use core::{
 };
 
 use alloc::{sync::Arc, vec, vec::Vec};
-use futures_util::{task::AtomicWaker, Future};
+use futures_util::Future;
 use libk_util::{
     sync::{IrqSafeSpinlock, IrqSafeSpinlockGuard},
     waker::QueueWaker,

userspace/lib/libterm/src/lib.rs

@@ -1,7 +1,9 @@
 #![cfg_attr(target_os = "yggdrasil", feature(yggdrasil_os, rustc_private))]
 
 use std::{
-    fmt, io::{self, stdin, stdout, Stdin, Stdout, Write}, ops::{Deref, DerefMut}, os::fd::{AsRawFd, RawFd}
+    fmt,
+    io::{self, stdin, stdout, Stdin, Stdout, Write},
+    os::fd::{AsRawFd, RawFd},
 };
 
 pub use self::{input::ReadChar, sys::RawMode};
@@ -28,8 +30,6 @@ pub enum Error {
     InputError(#[from] InputError),
 }
 
-pub struct RawStdin(Stdin, RawMode);
-
 pub trait RawTerminal {
     fn raw_enter_alternate_mode(&mut self) -> io::Result<()>;
     fn raw_leave_alternate_mode(&mut self) -> io::Result<()>;
@@ -133,34 +133,6 @@ impl RawTerminal for Stdout {
     }
 }
 
-impl RawStdin {
-    pub fn open() -> Result<Self, io::Error> {
-        let stdin = stdin();
-        let raw = unsafe { RawMode::enter(&stdin) }?;
-        Ok(Self(stdin, raw))
-    }
-}
-
-impl Deref for RawStdin {
-    type Target = Stdin;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl DerefMut for RawStdin {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
-impl AsRawFd for RawStdin {
-    fn as_raw_fd(&self) -> RawFd {
-        self.0.as_raw_fd()
-    }
-}
-
 impl Term {
     pub fn is_tty() -> bool {
         // TODO

userspace/rsh/src/crypt/client.rs

@@ -116,16 +116,17 @@ impl ClientSocket {
         self.remote
     }
 
-    // pub fn write_all(&mut self, data: &[u8]) -> Result<(), Error> {
-    //     let len = self.symmetric.encrypt(data, &mut self.buffer)?;
-    //     self.stream.write_all(&self.buffer[..len]).map_err(Error::from)
-    // }
-
     pub fn write_all<E: Encode>(&mut self, message: &E) -> Result<(), Error> {
         let mut buf = [0; 256];
         let mut encoder = Encoder::new(&mut buf);
         message.encode(&mut encoder)?;
-        let len = self.symmetric.encrypt(encoder.get(), &mut self.buffer[size_of::<u16>()..])?;
+
+        // Insert signature
+        let (payload, rest) = encoder.split_mut();
+        let payload_len = payload.len();
+        let signature_len = self.signer.sign(payload, rest)?;
+
+        let len = self.symmetric.encrypt(&buf[..payload_len + signature_len], &mut self.buffer[size_of::<u16>()..])?;
         let len_bytes: u16 = len.try_into().unwrap();
         self.buffer[..size_of::<u16>()].copy_from_slice(&len_bytes.to_le_bytes());
         self.stream.write_all(&self.buffer[..len + size_of::<u16>()])?;
@@ -157,6 +158,11 @@ impl ClientSocket {
             let data_len = self.symmetric.decrypt(&self.buffer[..len], buffer)?;
             let mut decoder = Decoder::new(&buffer[..data_len]);
             let message = D::decode(&mut decoder)?;
+
+            // Verify signature
+            let (payload, signature) = decoder.split();
+            self.verifier.verify(payload, signature)?;
+
             Ok(Some(message))
         } else {
             // Buffer doesn't contain a full message yet

userspace/rsh/src/crypt/signature.rs

@@ -1,11 +1,9 @@
-use std::{borrow::Cow, fmt, io::Write, path::Path};
+use std::{borrow::Cow, io::Write, path::Path};
 
 use ed25519_dalek::{ed25519::signature::SignerMut, pkcs8::DecodePrivateKey};
 use sha2::Digest;
 
-// use crate::Error;
+use super::V1_SIG_ED25519;
-
-use super::{sig_algo_name, V1_SIG_ED25519};
 
 pub struct SignEd25519 {
     signing_key: ed25519_dalek::SigningKey,
@@ -93,7 +91,8 @@ impl SignEd25519 {
     }
 
     pub fn load_signing_key<P: AsRef<Path>>(path: P) -> Result<Self, Error> {
-        let signing_key = ed25519_dalek::SigningKey::read_pkcs8_pem_file(path).map_err(|_| Error::InvalidKey)?;
+        let signing_key =
+            ed25519_dalek::SigningKey::read_pkcs8_pem_file(path).map_err(|_| Error::InvalidKey)?;
         let verifying_key = signing_key.verifying_key();
         Ok(Self {
             signing_key,

userspace/rsh/src/lib.rs

@@ -6,57 +6,9 @@ pub mod socket;
 pub mod crypt;
 pub mod proto;
 pub mod server;
-// use std::io;
+
-//
+pub enum Message<T> {
-// use proto::{DecodeError, EncodeError};
+    None,
-//
+    Closed,
-// pub mod proto;
+    Some(T),
-// pub mod socket;
+}
-// pub mod crypt;
-// pub mod server;
-//
-// pub use socket::{ClientSocket, ServerSocket};
-//
-// #[derive(Debug, thiserror::Error)]
-// pub enum Error {
-//     #[error("I/O error: {0}")]
-//     Io(#[from] io::Error),
-//     #[error("Could not send a message fully")]
-//     Truncated,
-//     #[error("Decode error: {0}")]
-//     Decode(#[from] DecodeError),
-//     #[error("Encode error: {0}")]
-//     Encode(#[from] EncodeError),
-//     #[error("Peer not connected")]
-//     NotConnected,
-//     #[error("Ping")]
-//     Ping,
-//     #[error("Invalid socket state")]
-//     InvalidState,
-//     #[error("Disconnected by remote peer")]
-//     Disconnected,
-//     #[error("Message too large: buffer size {0}, message size {1}")]
-//     MessageTooLarge(usize, usize),
-//     #[error("Cannot sign message: buffer size {0}, signature size {1}")]
-//     CannotFitSignature(usize, usize),
-//     #[error("Malformed ciphertext")]
-//     InvalidCiphertext,
-//     #[error("Message signature mismatch")]
-//     InvalidSignature,
-//     #[error("Invalid signature size ({0})")]
-//     InvalidSignatureSize(usize),
-//     #[error("Malformed encryption key")]
-//     InvalidKey,
-//     #[error("Communication timed out")]
-//     Timeout,
-//     #[error("Cannot accept any of the offered ciphersuites")]
-//     UnacceptableCiphersuites,
-//     #[error("Cannot accept any of the offered signature methods")]
-//     UnacceptableSignatureMethods,
-//     #[error("No verifying key for remote signature method")]
-//     NoVerifyingKey,
-//     #[error("Message is not signed")]
-//     MissingSignature,
-//     #[error("Rejected remote public key")]
-//     PublicKeyRejected,
-// }

userspace/rsh/src/main.rs

@@ -62,18 +62,12 @@ struct RawStdin {
     raw: Option<RawMode>,
 }
 
-enum Input {
-    Command(Vec<u8>),
-    Stdin(RawStdin),
-}
-
 pub struct Client {
     poll: Poll,
     socket: ClientSocket,
     stdin: RawStdin,
     stdout: Stdout,
     stderr: Stderr,
-    need_bye: bool,
     last0: u8,
     last1: u8,
 }
@@ -145,7 +139,6 @@ impl Client {
             stderr,
             socket,
             poll,
-            need_bye: false,
             last0: 0,
             last1: 0,
         })
@@ -276,7 +269,7 @@ fn run_command(
                 let message = match socket.poll_read(&mut buffer)? {
                     Message::Data(data) => data,
                     Message::Incomplete => continue,
-                    Message::Closed => break
+                    Message::Closed => break,
                 };
 
                 match message {
@@ -288,7 +281,7 @@ fn run_command(
                         stderr.write_all(output).ok();
                         stderr.flush().ok();
                     }
-                    _ => todo!()
+                    _ => todo!(),
                 }
             }
             _ if fd == stdin.as_raw_fd() => {
@@ -300,9 +293,8 @@ fn run_command(
                     socket.write_all(&ClientMessage::Input(&buffer[..len]))?;
                 }
             }
-            _ => unreachable!()
+            _ => unreachable!(),
         }
-
     }
 
     Ok(ExitCode::SUCCESS)

userspace/rsh/src/server.rs

@@ -2,10 +2,10 @@ use std::{
     collections::{hash_map::Entry, HashMap},
     fmt,
     hint::unreachable_unchecked,
-    io::{self, Read, Stdout, Write},
+    io::{self, Read, Write},
     net::SocketAddr,
     os::fd::{AsRawFd, RawFd},
-    process::{Child, Command, Stdio},
+    process::{Child, Command},
     time::Duration,
 };
 
@@ -306,7 +306,6 @@ impl<T: Session> ClientSet<T> {
 
             Ok(())
         } else if let Some(&key) = self.session_fd_map.get(&fd) {
-            log::debug!("poll fd {:?}", fd);
             let client = self.clients.get_mut(&key).unwrap();
             let peer = client.stream.remote_address();
 
@@ -397,7 +396,6 @@ impl<T: Session> ClientSet<T> {
                 len -= amount;
             }
 
-            log::debug!("Done");
             Ok(())
         } else {
             unreachable!()
@@ -412,10 +410,7 @@ impl PendingCommand {
         buffer: &mut [u8],
     ) -> CommandEvent {
         if let Some(stdout) = self.stdout.as_mut() && fd == stdout.as_raw_fd() {
-            log::debug!("poll stdout");
+            return CommandEvent::Output(StreamIndex::Stdout, stdout.read(buffer));
-            let res = stdout.read(buffer);
-            log::debug!(">> {:?}", res);
-            return CommandEvent::Output(StreamIndex::Stdout, res);
         }
         if let Some(stderr) = self.stderr.as_mut() && fd == stderr.as_raw_fd() {
             return CommandEvent::Output(StreamIndex::Stderr, stderr.read(buffer));

userspace/rsh/src/socket.rs

@@ -1,211 +0,0 @@
-use crate::proto::{Decode, DecodeError, Decoder, Encode, EncodeError, Encoder};
-
-pub enum Message<T> {
-    None,
-    Closed,
-    Some(T),
-}
-
-// use std::{
-//     io,
-//     marker::PhantomData,
-//     net::{SocketAddr, UdpSocket},
-//     ops::{Deref, DerefMut},
-//     os::fd::{AsRawFd, RawFd},
-// };
-//
-// use crate::{
-//     proto::{
-//         ClientMessageProxy, Decode, Decoder, Encode, Encoder, MessageProxy, ServerMessageProxy,
-//     },
-//     Error,
-// };
-//
-// pub struct SocketWrapper<S: PacketSocket, Rx: MessageProxy, Tx: MessageProxy> {
-//     socket: S,
-//     _pd: PhantomData<(Rx, Tx)>,
-// }
-//
-// pub trait MessageSocket<Rx: MessageProxy, Tx: MessageProxy>: AsRawFd {
-//     fn send(&mut self, buffer: &mut [u8], data: &Tx::Type<'_>) -> Result<(), Error>;
-//     fn send_to(
-//         &mut self,
-//         addr: &SocketAddr,
-//         buffer: &mut [u8],
-//         data: &Tx::Type<'_>,
-//     ) -> Result<(), Error>;
-//     fn recv_from<'de>(
-//         &mut self,
-//         buffer: &'de mut [u8],
-//     ) -> Result<(Rx::Type<'de>, SocketAddr), Error>;
-// }
-//
-// pub trait PacketSocket: AsRawFd {
-//     type Error: Into<Error>;
-//
-//     fn send(&mut self, data: &[u8]) -> Result<usize, Self::Error>;
-//     fn send_to(&mut self, data: &[u8], addr: &SocketAddr) -> Result<usize, Self::Error>;
-//     fn recv_from(&mut self, data: &mut [u8]) -> Result<(usize, SocketAddr), Self::Error>;
-// }
-//
-// pub enum MultiplexedSocketEvent<'a> {
-//     ClientData(SocketAddr, &'a [u8]),
-//     ClientDisconnected(SocketAddr),
-//     None(SocketAddr),
-//     Error(Error)
-// }
-//
-// pub trait MultiplexedSocket: AsRawFd {
-//     fn recv_from<'a>(&mut self, buffer: &'a mut [u8]) -> Result<MultiplexedSocketEvent<'a>, Error>;
-//     fn send_to(&mut self, remote: &SocketAddr, data: &[u8]) -> Result<(), Error>;
-//
-//     fn send_message_to<Tx: Encode>(
-//         &mut self,
-//         remote: &SocketAddr,
-//         buffer: &mut [u8],
-//         data: &Tx,
-//     ) -> Result<(), Error> {
-//         let mut encoder = Encoder::new(buffer);
-//         data.encode(&mut encoder)?;
-//         self.send_to(remote, encoder.get())
-//     }
-// }
-//
-// impl PacketSocket for UdpSocket {
-//     type Error = io::Error;
-//
-//     fn send(&mut self, data: &[u8]) -> Result<usize, Self::Error> {
-//         UdpSocket::send(self, data)
-//     }
-//
-//     fn send_to(&mut self, data: &[u8], addr: &SocketAddr) -> Result<usize, Self::Error> {
-//         UdpSocket::send_to(self, data, addr)
-//     }
-//
-//     fn recv_from(&mut self, data: &mut [u8]) -> Result<(usize, SocketAddr), Self::Error> {
-//         UdpSocket::recv_from(self, data)
-//     }
-// }
-//
-// pub struct ClientSocket<S: PacketSocket>(SocketWrapper<S, ServerMessageProxy, ClientMessageProxy>);
-// pub struct ServerSocket<S: MultiplexedSocket>(S);
-//
-// impl<S: PacketSocket, Rx: MessageProxy, Tx: MessageProxy> MessageSocket<Rx, Tx>
-//     for SocketWrapper<S, Rx, Tx>
-// {
-//     fn send(&mut self, buffer: &mut [u8], data: &Tx::Type<'_>) -> Result<(), Error> {
-//         let mut enc = Encoder::new(buffer);
-//         data.encode(&mut enc)?;
-//         let message = enc.get();
-//         let amount = self.socket.send(message).map_err(S::Error::into)?;
-//         if amount == message.len() {
-//             Ok(())
-//         } else {
-//             Err(Error::Truncated)
-//         }
-//     }
-//
-//     fn send_to(
-//         &mut self,
-//         addr: &SocketAddr,
-//         buffer: &mut [u8],
-//         data: &Tx::Type<'_>,
-//     ) -> Result<(), Error> {
-//         let mut enc = Encoder::new(buffer);
-//         data.encode(&mut enc)?;
-//         let message = enc.get();
-//         let amount = self.socket.send_to(message, addr).map_err(S::Error::into)?;
-//         if amount == message.len() {
-//             Ok(())
-//         } else {
-//             Err(Error::Truncated)
-//         }
-//     }
-//
-//     fn recv_from<'de>(
-//         &mut self,
-//         buffer: &'de mut [u8],
-//     ) -> Result<(Rx::Type<'de>, SocketAddr), Error> {
-//         let (len, remote) = self.socket.recv_from(buffer).map_err(S::Error::into)?;
-//         let mut dec = Decoder::new(&buffer[..len]);
-//         let message = Rx::Type::<'de>::decode(&mut dec)?;
-//         Ok((message, remote))
-//     }
-// }
-//
-// impl<S: PacketSocket, Rx: MessageProxy, Tx: MessageProxy> SocketWrapper<S, Rx, Tx> {
-//     pub fn new(socket: S) -> Self {
-//         Self {
-//             socket,
-//             _pd: PhantomData,
-//         }
-//     }
-//
-//     pub fn into_inner(self) -> S {
-//         self.socket
-//     }
-//
-//     pub fn as_inner_mut(&mut self) -> &mut S {
-//         &mut self.socket
-//     }
-// }
-//
-// impl<S: PacketSocket, Rx: MessageProxy, Tx: MessageProxy> AsRawFd for SocketWrapper<S, Rx, Tx> {
-//     fn as_raw_fd(&self) -> RawFd {
-//         self.socket.as_raw_fd()
-//     }
-// }
-//
-// impl<S: PacketSocket> ClientSocket<S> {
-//     pub fn new(socket: S) -> Self {
-//         Self(SocketWrapper::new(socket))
-//     }
-// }
-//
-// impl<S: PacketSocket> Deref for ClientSocket<S> {
-//     type Target = SocketWrapper<S, ServerMessageProxy, ClientMessageProxy>;
-//
-//     fn deref(&self) -> &Self::Target {
-//         &self.0
-//     }
-// }
-//
-// impl<S: PacketSocket> DerefMut for ClientSocket<S> {
-//     fn deref_mut(&mut self) -> &mut Self::Target {
-//         &mut self.0
-//     }
-// }
-//
-// impl<S: MultiplexedSocket> ServerSocket<S> {
-//     pub fn new(socket: S) -> Self {
-//         Self(socket)
-//     }
-// }
-//
-// impl<S: MultiplexedSocket> Deref for ServerSocket<S> {
-//     type Target = S;
-//
-//     fn deref(&self) -> &Self::Target {
-//         &self.0
-//     }
-// }
-//
-// impl<S: MultiplexedSocket> DerefMut for ServerSocket<S> {
-//     fn deref_mut(&mut self) -> &mut Self::Target {
-//         &mut self.0
-//     }
-// }
-//
-// // impl<S: PacketSocket> Deref for ServerSocket<S> {
-// //     type Target = SocketWrapper<S, ClientMessageProxy, ServerMessageProxy>;
-// //
-// //     fn deref(&self) -> &Self::Target {
-// //         &self.0
-// //     }
-// // }
-// //
-// // impl<S: PacketSocket> DerefMut for ServerSocket<S> {
-// //     fn deref_mut(&mut self) -> &mut Self::Target {
-// //         &mut self.0
-// //     }
-// // }