test5

Author: baluluyakalulu

tun_test4/Cargo.toml

@@ -7,10 +7,10 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-#tokio-tun = "0.3.5"
-tokio-tun = { git = "https://github.com/hankbao/tokio-tun.git" }
+tokio-tun = "0.3.5"
+#tokio-tun = { git = "https://github.com/hankbao/tokio-tun.git" }
 tokio = { version = "1.1", features = ["net"] }
-mio = "0.6"
+#mio = "0.6"
 
 libc = "0.2"
 nix = "0.19"

tun_test4/MEMO.txt

@@ -1 +1,4 @@
 sudo ./target/debug/tun_rust
+
+sudo tshark -i tun0
+

tun_test4/src/main.rs

@@ -3,6 +3,7 @@
 use std::net::Ipv4Addr;
 use std::os::unix::io::AsRawFd;
 use tokio::io::AsyncReadExt;
+use tokio::io::AsyncWriteExt;
 use tokio_tun::result::Result;
 use tokio_tun::TunBuilder;
 
@@ -95,12 +96,10 @@ async fn main() -> Result<()> {
     let mut buf = [0u8; 1024];
     loop {
         let n = reader.read(&mut buf).await?;
-        //println!("reading {} bytes: {:?}", n, &buf[..n]);
-        //let mut fake_ethernet_frame = MutableEthernetPacket::new(&mut buf[..n]).unwrap();
-        
-        //let fake_ethernet_frame = EthernetPacket::new(&mut buf[..n]).unwrap();
-        //capture_packet(&fake_ethernet_frame);
-        //
+
+        //_writer.write_all(&buf).await?;
+        _writer.write(&buf).await?;
+
         let header = Ipv4Packet::new(&mut buf[..n]).unwrap(); 
          println!("{} -> {}",header.get_source(), header.get_destination());
          let ihl = usize::from(header.get_header_length());
@@ -117,9 +116,12 @@ async fn main() -> Result<()> {
             header. get_next_level_protocol(),
             //&buf[20..n],
             &buf[hlen..n],
+            &buf,
             &mut _writer,
+            //tun,
         );
 
+
         //if let Some(header) = header {
         //                 //                   println!("{?}",header.get_source());
         //                                    //header.get_destination()

tun_test4/src/packet_handler.rs

@@ -16,8 +16,10 @@ use pnet::util::MacAddr;
 
 use tokio_tun::Tun;
 use tokio::io::WriteHalf;
+use tokio::io::AsyncReadExt;
 use tokio::io::AsyncWriteExt;
 //use tokio::io::Write;
+use tokio_tun::TunBuilder;
 
 //use std::env;
 //use std::io::{self, Write};
@@ -52,6 +54,7 @@ fn send_ipv4_packet(
     //tx: &TxSender,
     writer: &mut tokio::io::WriteHalf<Tun>,
 ) {
+    println!("send");
     let buf_size = MutableIpv4Packet::minimum_packet_size() + payload.len();
     let mut ip_packet = MutableIpv4Packet::owned(vec![0u8; buf_size]).unwrap();
 
@@ -75,7 +78,7 @@ fn send_ipv4_packet(
     //writer.write(ip_packet.packet());
     //let r = writer.write(ip_packet.packet());
     //writer.flush();
-    writer.write(ip_packet.packet());
+    writer.write_all(ip_packet.packet());
     writer.flush();
     //println!("send:{:?}", ret);
 
@@ -105,7 +108,13 @@ fn send_ipv4_packet(
     //};
 }
 
-fn handle_icmp_packet(interface_name: &str, source: IpAddr, destination: IpAddr, packet: &[u8], writer: &mut tokio::io::WriteHalf<Tun>) {
+fn handle_icmp_packet(interface_name: &str, source: IpAddr, destination: IpAddr, 
+packet: &[u8],
+recv_packet: &[u8],
+ writer: &mut tokio::io::WriteHalf<Tun>) {
+
+    writer.write_all(&recv_packet);
+
     let icmp_packet = IcmpPacket::new(packet);
     if let Some(icmp_packet) = icmp_packet {
         match icmp_packet.get_icmp_type() {
@@ -121,6 +130,8 @@ fn handle_icmp_packet(interface_name: &str, source: IpAddr, destination: IpAddr,
                 );
             }
             IcmpTypes::EchoRequest => {
+                 println!("recv");
+                 writer.write_all(&recv_packet);
                 let echo_request_packet = echo_request::EchoRequestPacket::new(packet).unwrap();
                 println!(
                     "[{}]: ICMP echo request {} -> {} (seq={:?}, id={:?})",
@@ -156,6 +167,7 @@ fn handle_icmp_packet(interface_name: &str, source: IpAddr, destination: IpAddr,
                 //////////////////////////////////////////
                 */
          let mut echo_reply_packet =
+                    
                     echo_reply::MutableEchoReplyPacket::owned(packet.to_vec()).unwrap();
                 echo_reply_packet.set_icmp_type(IcmpTypes::EchoReply);
                 let icmp_packet = IcmpPacket::new(echo_reply_packet.packet()).unwrap();
@@ -229,6 +241,7 @@ pub fn handle_transport_protocol(
     destination: IpAddr,
     protocol: IpNextHeaderProtocol,
     packet: &[u8],
+    recv_packet: &[u8],
     writer: &mut tokio::io::WriteHalf<Tun>,
 ) {
     match protocol {
@@ -239,7 +252,7 @@ pub fn handle_transport_protocol(
             handle_tcp_packet(interface_name, source, destination, packet, writer)
         }
         IpNextHeaderProtocols::Icmp => {
-            handle_icmp_packet(interface_name, source, destination, packet, writer)
+            handle_icmp_packet(interface_name, source, destination, packet, recv_packet, writer)
         }
         IpNextHeaderProtocols::Icmpv6 => {
             handle_icmpv6_packet(interface_name, source, destination, packet, writer)
@@ -259,6 +272,21 @@ pub fn handle_transport_protocol(
     }
 }
 
+pub async fn handle_transport_protocol2(
+    interface_name: &str,
+    source: IpAddr,
+    destination: IpAddr,
+    protocol: IpNextHeaderProtocol,
+    packet: &[u8],
+    recv_packet: &[u8],
+    //writer: &mut tokio::io::WriteHalf<Tun>,
+    tun:  Tun,
+)  {
+      let (mut reader, mut _writer) = tokio::io::split(tun);
+
+       //_writer.write(&recv_packet);
+}
+
 pub fn handle_ipv4_packet(interface_name: &str, ethernet: &EthernetPacket, writer: &mut tokio::io::WriteHalf<Tun>) {
     let header = Ipv4Packet::new(ethernet.payload());
     if let Some(header) = header {
@@ -268,6 +296,7 @@ pub fn handle_ipv4_packet(interface_name: &str, ethernet: &EthernetPacket, write
             IpAddr::V4(header.get_destination()),
             header.get_next_level_protocol(),
             header.payload(),
+            header.payload(),
             writer,
         );
     } else {
@@ -284,6 +313,7 @@ pub fn handle_ipv6_packet(interface_name: &str, ethernet: &EthernetPacket, write
             IpAddr::V6(header.get_destination()),
             header.get_next_header(),
             header.payload(),
+            header.payload(),
             writer,
         );
     } else {