wg-webclient: fix cargo clippy

Author: ffreddow

wg-webclient/src/hyper_stream.rs

@@ -49,7 +49,7 @@ impl hyper::rt::Read for HyperStream {
         let mut stream = self.stream.borrow_mut();
         stream.poll();
         if !stream.can_recv() {
-            cx.waker().clone().wake();
+            cx.waker().wake_by_ref();
             return Poll::Pending;
         }
         let write_buf = unsafe { buf.as_mut() };
@@ -77,8 +77,7 @@ impl hyper::rt::Write for HyperStream {
         let mut stream = self.stream.borrow_mut();
         match stream.write(buf) {
             Ok(len) => Poll::Ready(Ok(len)),
-            Err(_) => Poll::Ready(Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
+            Err(_) => Poll::Ready(Err(std::io::Error::other(
                 "failed to write data",
             ))),
         }
@@ -96,8 +95,7 @@ impl hyper::rt::Write for HyperStream {
         }
         match stream.flush() {
             Ok(_) => Poll::Ready(Ok(())),
-            Err(err) => Poll::Ready(Err(std::io::Error::new(
-                std::io::ErrorKind::Other,
+            Err(err) => Poll::Ready(Err(std::io::Error::other(
                 format!("failed to flush data: {:?}", err),
             ))),
         }

wg-webclient/src/interface.rs

@@ -64,7 +64,7 @@ impl<'a, Device: phy::Device + IsUp> Interface<'a, Device> {
     }
 
     #[inline]
-    pub fn get_socket(&self, handle: SocketHandle) -> &Socket {
+    pub fn get_socket(&self, handle: SocketHandle) -> &Socket<'_> {
         self.sockets.get::<Socket>(handle)
     }
 

wg-webclient/src/lib.rs

@@ -13,7 +13,7 @@ use wasm_bindgen::prelude::*;
 
 #[macro_export]
 macro_rules! console_log {
-    ($($t:tt)*) => (crate::utils::log(&format_args!($($t)*).to_string()))
+    ($($t:tt)*) => ($crate::utils::log(&format_args!($($t)*).to_string()))
 }
 
 #[wasm_bindgen]

wg-webclient/src/stream.rs

@@ -131,7 +131,7 @@ impl<Device: phy::Device + Clone + IsUp> Write for TcpStream<'_, Device> {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
         let mut inner_buf = self.buf.borrow_mut();
-        Ok(inner_buf.write(buf)?)
+        inner_buf.write(buf)
     }
 
     #[inline]
@@ -140,7 +140,7 @@ impl<Device: phy::Device + Clone + IsUp> Write for TcpStream<'_, Device> {
         match self
             .iface
             .borrow_mut()
-            .send_slice(self.handle, &mut buf[..])
+            .send_slice(self.handle, &buf[..])
         {
             Ok(sent) => {
                 if sent != buf.len() {
@@ -149,8 +149,7 @@ impl<Device: phy::Device + Clone + IsUp> Write for TcpStream<'_, Device> {
                 }
             }
             Err(e) => {
-                return Err(std::io::Error::new(
-                    std::io::ErrorKind::Other,
+                return Err(std::io::Error::other(
                     format!("failed to send data: {:?}", e),
                 ))
             }
@@ -192,8 +191,7 @@ impl<Device: phy::Device + Clone + IsUp> Read for TcpStream<'_, Device> {
             Ok(len) => Ok(len),
             Err(e) => match e {
                 RecvError::Finished => Ok(0),
-                RecvError::InvalidState => Err(std::io::Error::new(
-                    std::io::ErrorKind::Other,
+                RecvError::InvalidState => Err(std::io::Error::other(
                     "failed to recv data",
                 )),
             },

wg-webclient/src/websocket.rs

@@ -107,13 +107,10 @@ where
     }
 
     pub fn disconnect(&self) {
-        match &*self.state.borrow_mut() {
-            WebsocketState::Connected(state) => {
-                let mut socket = state.stream.borrow_mut();
-                let _ = socket.close(None);
-                let _ = socket.flush();
-            }
-            _ => (),
+        if let WebsocketState::Connected(state) = &*self.state.borrow_mut() {
+            let mut socket = state.stream.borrow_mut();
+            let _ = socket.close(None);
+            let _ = socket.flush();
         }
     }
 
@@ -167,7 +164,7 @@ fn create_setup_closure<Device>(
         let read: usize = match stream.read(&mut buf) {
             Ok(len) => len,
             Err(e) => {
-                log::error!("error while reading from stream: {}", e.to_string());
+                log::error!("error while reading from stream: {}", e);
                 return;
             }
         };
@@ -180,13 +177,13 @@ fn create_setup_closure<Device>(
                     return;
                 }
                 Err(e) => {
-                    log::error!("error while parsing response: {}", e.to_string());
+                    log::error!("error while parsing response: {}", e);
                     return;
                 }
             };
 
         if let Some(accept_key) = response.headers().get("Sec-WebSocket-Accept") {
-            if accept_key.as_bytes() != derive_accept_key(&key.as_bytes()).as_bytes() {
+            if accept_key.as_bytes() != derive_accept_key(key.as_bytes()).as_bytes() {
                 panic!("invalid accept key");
             }
         } else {
@@ -251,7 +248,7 @@ fn create_websocket_closure<Device>(
                         },
                         _ => log::error!(
                             "error while reading from Websocket: {}",
-                            e.to_string()
+                            e
                         ),
                     }
                     return;

wg-webclient/src/wg_client.rs

@@ -37,21 +37,28 @@ use wasm_bindgen::prelude::*;
 use wasm_bindgen_futures::JsFuture;
 use web_sys::{CustomEvent, MessageEvent, Response};
 
+type EventClosure = Closure<dyn FnMut(CustomEvent)>;
+type EventQueue = Rc<RefCell<VecDeque<EventClosure>>>;
+type HyperResp = hyper::Response<hyper::body::Incoming>;
+type RequestFuture = Pin<Box<dyn Future<Output = hyper::Result<HyperResp>>>>;
+type ConnPin = Pin<Box<Connection<HyperStream, Box<Body>>>>;
+type RespPin = Pin<Box<HyperResp>>;
 
 /// The exported client struct. It Wraps the actual Client and a Queue to keep the needed
 /// callbacks alive.
 /// Most function calls are simply passed to the wrapped object.
 #[wasm_bindgen]
 pub struct Client(
     WgClient,
-    Rc<RefCell<VecDeque<Closure<dyn FnMut(CustomEvent)>>>>,
+    EventQueue,
 );
 
 #[wasm_bindgen]
 impl Client {
 
     /// Creates a new Client struct by also creating the wrapped objects.
     #[wasm_bindgen(constructor)]
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         secret_str: &str,
         peer_str: &str,
@@ -178,6 +185,7 @@ enum RequestState {
 impl WgClient {
 
     /// Creates a new object.
+    #[allow(clippy::too_many_arguments)]
     fn new(
         secret_str: &str,
         peer_str: &str,
@@ -231,7 +239,7 @@ impl WgClient {
             current_request: Rc::new(RefCell::new(None)),
             request_queue: Rc::new(RefCell::new(VecDeque::new())),
             pcap,
-            internal_peer_ip: (&internal_peer_ip[0..internal_peer_ip.len() - 3]).to_string(),
+            internal_peer_ip: internal_peer_ip[0..internal_peer_ip.len() - 3].to_string(),
             _polling_interval: polling_interval,
             username: Rc::new(RefCell::new(String::new())),
             password: Rc::new(RefCell::new(String::new())),
@@ -252,9 +260,9 @@ impl WgClient {
         let port = port as u16;
         let endpoint = smoltcp::wire::IpEndpoint::new(self.internal_peer_ip.parse().unwrap(), self.port);
         if let Err(err) = stream.connect(endpoint, port) {
-            log::error!("Error when connecting websocket: {}", err.to_string());
+            log::error!("Error when connecting websocket: {}", err);
         }
-        let auth_header = if self.nonce.borrow().len() != 0 {
+        let auth_header = if !self.nonce.borrow().is_empty() {
             Some(self.build_authentication_header("GET", "/ws"))
         } else {
             None
@@ -269,7 +277,7 @@ impl WgClient {
         let ha1 = md5::compute(format!("{}:{}:{}", self.username.borrow(), self.realm.borrow(), self.password.borrow()));
         let ha2 = md5::compute(format!("{}:{}", method, uri));
 
-        let this: JsValue = js_sys::global().try_into().unwrap();
+        let this: JsValue = js_sys::global().into();
         let this = web_sys::WorkerGlobalScope::from(this);
         let crypto = this.crypto().unwrap();
 
@@ -367,7 +375,7 @@ impl WgClient {
 
                     // FIXME: throw exception instead of panic
                     if let Err(err) = stream.upgrade().unwrap().borrow_mut().connect(endpoint, out_port) {
-                        log::error!("Error connecting to endpoint {}: {}", endpoint, err.to_string());
+                        log::error!("Error connecting to endpoint {}: {}", endpoint, err);
                         return;
                     }
                     *state_ref = RequestState::Started;
@@ -429,7 +437,7 @@ impl WgClient {
         let document = window.document().unwrap();
         let element = document.create_element("a").unwrap();
         element.set_attribute("download", "out.pcap").unwrap();
-        element.set_attribute("href", &file.to_string()).unwrap();
+        element.set_attribute("href", &file).unwrap();
         element.set_attribute("target", "_blank").unwrap();
         let element = wasm_bindgen::JsValue::from(element);
         let element = web_sys::HtmlElement::from(element);
@@ -451,7 +459,7 @@ impl WgClient {
 
 
 /// Transforms the raw tcp stream into sender and receiver objects for hyper.
-fn setup_connection(sender: Weak<RefCell<Option<SendRequest<Box<Body>>>>>, conn: Weak<RefCell<Option<std::pin::Pin<Box<Connection<HyperStream, Box<Body>>>>>>>, state: Weak<RefCell<RequestState>>, stream: Weak<RefCell<TcpStream<'static, WgTunDevice>>>) {
+fn setup_connection(sender: Weak<RefCell<Option<SendRequest<Box<Body>>>>>, conn: Weak<RefCell<Option<ConnPin>>>, state: Weak<RefCell<RequestState>>, stream: Weak<RefCell<TcpStream<'static, WgTunDevice>>>) {
     wasm_bindgen_futures::spawn_local(async move {
         let stream = HyperStream::new(stream.upgrade().unwrap().clone());
 
@@ -470,7 +478,7 @@ fn send_http_reqeust(
     js_request: Rc<web_sys::Request>,
     url: Rc<String>,
     sender: Weak<RefCell<Option<SendRequest<Box<Body>>>>>,
-    request: Weak<RefCell<Option<Pin<Box<dyn Future<Output = hyper::Result<hyper::Response<hyper::body::Incoming>>>>>>>>,
+    request: Weak<RefCell<Option<RequestFuture>>>,
     state: Weak<RefCell<RequestState>>,
     self_cpy: WgClient,
 ) {
@@ -502,7 +510,7 @@ fn send_http_reqeust(
             req = req.header(key, value);
         }
 
-        if self_cpy.nonce.borrow().len() != 0 {
+        if !self_cpy.nonce.borrow().is_empty() {
             let auth_header = self_cpy.build_authentication_header(&method_str, &url);
             req = req.header("Authorization", auth_header);
         }
@@ -525,10 +533,10 @@ fn send_http_reqeust(
 
 /// Polls the sending end of the hyper connection until the request is sent.
 fn poll_request(
-    request: Rc<RefCell<Option<Pin<Box<dyn Future<Output = hyper::Result<hyper::Response<hyper::body::Incoming>>>>>>>>,
-    resp: Rc<RefCell<Option<Pin<Box<hyper::Response<hyper::body::Incoming>>>>>>,
+    request: Rc<RefCell<Option<RequestFuture>>>,
+    resp: Rc<RefCell<Option<RespPin>>>,
     mut state: std::cell::RefMut<'_, RequestState>,
-    conn: Rc<RefCell<Option<std::pin::Pin<Box<Connection<HyperStream, Box<Body>>>>>>>,
+    conn: Rc<RefCell<Option<ConnPin>>>,
 ) {
     let waker = futures::task::noop_waker();
     let mut cx = std::task::Context::from_waker(&waker);
@@ -556,12 +564,12 @@ fn poll_request(
 
 /// Collects the raw response stream and parses it into a Response object.
 fn poll_response(
-    resp: Rc<RefCell<Option<Pin<Box<hyper::Response<hyper::body::Incoming>>>>>>,
+    resp: Rc<RefCell<Option<RespPin>>>,
     result: Rc<RefCell<Vec<u8>>>,
     mut state_ref: std::cell::RefMut<'_, RequestState>,
     self_cpy: WgClient,
     id: f64,
-    conn: Rc<RefCell<Option<std::pin::Pin<Box<Connection<HyperStream, Box<Body>>>>>>>,
+    conn: Rc<RefCell<Option<ConnPin>>>,
 ) {
     let waker = futures::task::noop_waker();
     let mut cx = std::task::Context::from_waker(&waker);

wg-webclient/src/wg_device.rs

@@ -58,10 +58,10 @@ pub struct WgTunDevice {
     socket: Rc<WebSocket>,
     socket_state: Rc<RefCell<WsConnectionState>>,
     _reset_rate_limiter_interval: Rc<IntervalHandle<JsValue>>,
-    _onopen_closure: Rc<Closure<dyn FnMut(JsValue) -> ()>>,
-    _onclose_closure: Rc<Closure<dyn FnMut(JsValue) -> ()>>,
-    _onerror_closure: Rc<Closure<dyn FnMut(JsValue) -> ()>>,
-    _onmessage_closure: Rc<Closure<dyn FnMut(MessageEvent) -> ()>>,
+    _onopen_closure: Rc<Closure<dyn FnMut(JsValue)>>,
+    _onclose_closure: Rc<Closure<dyn FnMut(JsValue)>>,
+    _onerror_closure: Rc<Closure<dyn FnMut(JsValue)>>,
+    _onmessage_closure: Rc<Closure<dyn FnMut(MessageEvent)>>,
 }
 
 impl WgTunDevice {
@@ -151,7 +151,7 @@ fn create_onopen_closure(
     onopen_socket_state: Weak<RefCell<WsConnectionState>>,
     onopen_tun: Weak<RefCell<Tunn>>,
     onopen_socket: Weak<WebSocket>,
-) -> Closure<dyn FnMut(JsValue) -> ()> {
+) -> Closure<dyn FnMut(JsValue)> {
     Closure::<dyn FnMut(_)>::new(move |_: JsValue| {
         log::debug!("Parent WebSocket Opened");
         let onopen_socket_state = onopen_socket_state.upgrade().unwrap();
@@ -199,7 +199,7 @@ fn create_onmessage_closure(
     message_vec: Weak<RefCell<VecDeque<Vec<u8>>>>,
     message_pcap: Weak<RefCell<PcapNgWriter<Vec<u8>>>>,
     connect_cb: js_sys::Function,
-) -> Closure<dyn FnMut(MessageEvent) -> ()> {
+) -> Closure<dyn FnMut(MessageEvent)> {
     let connected = Rc::new(RefCell::new(false));
     Closure::<dyn FnMut(_)>::new(move |e: MessageEvent| {
         let data = e.data();
@@ -233,7 +233,7 @@ fn create_onmessage_closure(
                 TunnResult::WriteToNetwork(d) => {
                     if pcap_logging_enabled() {
                         let pcap_strong = message_pcap.upgrade().unwrap();
-                        log_pcap_data(&pcap_strong, &d);
+                        log_pcap_data(&pcap_strong, d);
                     }
                     let mut connected = connected.borrow_mut();
                     if !*connected {
@@ -256,7 +256,7 @@ fn create_onmessage_closure(
                     {
                         if pcap_logging_enabled() {
                             let pcap_strong = message_pcap.upgrade().unwrap();
-                            log_pcap_data(&pcap_strong, &d);
+                            log_pcap_data(&pcap_strong, d);
                         }
                         let _ = message_socket.send_with_u8_array(d);
                     }
@@ -273,7 +273,7 @@ fn create_onmessage_closure(
                 TunnResult::WriteToTunnelV4(d, _) => {
                     if pcap_logging_enabled() {
                         let pcap_strong = message_pcap.upgrade().unwrap();
-                        log_pcap_data(&pcap_strong, &d);
+                        log_pcap_data(&pcap_strong, d);
                     }
                     let message_vec = message_vec.upgrade().unwrap();
                     (*message_vec.borrow_mut()).push_back(d.to_vec());