transmute

src/main.rs

@@ -98,24 +98,14 @@ fn main() -> Result<(), Box<dyn Error>> {
                 buffer[..meta_size].copy_from_slice(meta_bytes);
 
                 loop {
-                    match router.tun_reader.read(&mut buffer[meta_size..]) {
-                        Ok(n) if n > 0 => {
-                            // If we have a known remote address, encrypt and send
-                            if let Some(ref addr) = *router.endpoint.read().unwrap() {
-                                router.encrypt(&mut buffer[meta_size..meta_size + n]);
-                                #[cfg(target_os = "linux")]
-                                router.socket.set_mark(router.config.mark)?;
-                                if let Err(e) =
-                                    router.socket.send_to(&buffer[..meta_size + n], addr)
-                                {
-                                    eprintln!("Error sending packet: {}", e);
-                                }
-                            } else {
-                                eprintln!("No remote address set; packet dropped.");
-                            }
+                    let n = router.tun_reader.read(&mut buffer[meta_size..]).unwrap();
+                    if let Some(ref addr) = *router.endpoint.read().unwrap() {
+                        router.encrypt(&mut buffer[meta_size..meta_size + n]);
+                        #[cfg(target_os = "linux")]
+                        router.socket.set_mark(router.config.mark)?;
+                        if let Err(e) = router.socket.send_to(&buffer[..meta_size + n], addr) {
+                            eprintln!("Error sending packet: {}", e);
                         }
-                        Err(e) => eprintln!("Error reading from TUN: {}", e),
-                        _ => {}
                     }
                 }
             });
@@ -125,37 +115,23 @@ fn main() -> Result<(), Box<dyn Error>> {
             s.spawn(move |_| {
                 let mut recv_buf = [MaybeUninit::uninit(); 1500];
                 loop {
-                    match socket.recv_from(&mut recv_buf) {
-                        Ok((len, addr)) => {
-                            let data: &mut [u8] = unsafe { transmute(&mut recv_buf[..len]) };
-
-                            if let Some(packet) = Ipv4Packet::new(data) {
-                                let header_len = packet.get_header_length() as usize * 4;
-                                let (_ip_header, rest) = data.split_at_mut(header_len);
-                                if rest.len() < size_of::<Meta>() {
-                                    continue;
-                                }
-                                let (meta_bytes, payload) = rest.split_at_mut(size_of::<Meta>());
-
-                                let meta = Meta {
-                                    src_id: meta_bytes[0],
-                                    dst_id: meta_bytes[1],
-                                    reversed: u16::from_le_bytes([meta_bytes[2], meta_bytes[3]]),
-                                };
+                    let (len, addr) = socket.recv_from(&mut recv_buf).unwrap();
+                    let data: &mut [u8] = unsafe { transmute(&mut recv_buf[..len]) };
 
-                                if let Some(router) = router_writers.get_mut(&meta.src_id) {
-                                    if meta.dst_id == config.local_id && meta.reversed == 0 {
-                                        *router.endpoint.write().unwrap() = Some(addr);
-                                        router.decrypt(payload);
-                                        router.tun_writer.write_all(payload).unwrap();
-                                    }
-                                } else {
-                                    // eprintln!("Dropping unexpected packet");
-                                }
+                    if let Some(packet) = Ipv4Packet::new(data) {
+                        let header_len = packet.get_header_length() as usize * 4;
+                        let (_ip_header, rest) = data.split_at_mut_checked(header_len).unwrap();
+                        let (meta_bytes, payload) = rest.split_at_mut_checked(size_of::<Meta>()).unwrap();
+                        let meta: &Meta = unsafe { transmute(meta_bytes.as_ptr()) };
+                        if let Some(router) = router_writers.get_mut(&meta.src_id) {
+                            if meta.dst_id == config.local_id && meta.reversed == 0 {
+                                *router.endpoint.write().unwrap() = Some(addr);
+                                router.decrypt(payload);
+                                router.tun_writer.write_all(payload).unwrap();
                             }
                         }
-                        Err(e) => eprintln!("Error receiving: {}", e),
                     }
+                    // Ok(())
                 }
             });
         }