minor edit

Author: e1732a364fed

doc/book/src/lua/map_config.md

@@ -147,6 +147,10 @@ out_auto_route = {
 }
 ```
 
+ip 拨号是建立一个虚拟网卡，一般为 tun. 这个一般可以用于配合 tcp/ip stack (smoltcp) 进行全局路由使用，详情
+见 local.lua 中的对应示例，以及 [这里](https://github.com/e1732a364fed/ruci/blob/tokio/doc/notes.md#tun模式的一些实测信息)
+
+
 ### OptDialer
 in
 

doc/notes.md

@@ -192,7 +192,7 @@ ruci chain 模式中,
 
 在ruci 中, 你可以:  dial 一个由 host1 解析得的ip, 然后 tls 里的 sni 写 host2, 然后 ws/grpc 的请求 url 中 写 host3
 
-## tun 模式的一些实测信息
+## tun模式的一些实测信息
 
 tun 是用 如下配置启用
 
@@ -208,13 +208,41 @@ tun 是用 如下配置启用
 
 详见 local.lua 中对应示例
 
-windows 上需要 wintun.dll. 可用ruci-cmd `ruci-cmd utils wintun` 来自动下载 wintun.zip
+windows 上需要 wintun.dll. 可用ruci-cmd `ruci-cmd utils wintun` 来自动下载 wintun.zip，wintun.zip 中还有子文件夹，
+一般要进入 amd64 文件夹中，解压出里面的 wintun.dll
 
 在windows上, 可以在控制面板中找到所建立的虚拟网卡
 
 
 实测, 在 windows 上, 就算不配置任何路由, 系统也会识别到它建立的虚拟网卡, 并向其发送一些信息；在 linux 和 macos 上, 也会收到少量信息（即会在log中显示一些输出）
 
+在 linux/macOS 上，运行要用 sudo , 在 windows 上，要用管理员权限运行程序，这样ruci-cmd 才能启动虚拟网卡。
+
+
+在  in_auto_route 的  ` original_dev_name = "en0"` 项 和  `sockopt` 的 `bind_to_device = "en0"` 项中,均要填写网卡名称信息
+
+在 linux/macOS 上用 ifconfig 查看, 在 windows 上用 ipconfig 查看。
+
+windows 上，根据系统语言不同，网卡名称也不同，比如 "ETHERNET" 在中文系统中为 "以太网"
+
+## smoltcp/lwip 与 tun
+
+smoltcp 和 lwip 是两种 tcp/ip stack 的实现
+
+lwip 无法在 windows 上编译。
+
+二者均需要使用 tun 包 或 tun2 包来作为底层tun device.
+
+一开始，先有 tun包，后来作者不维护了，又出现了tun2包，但是到了 24年年底，
+tun2包的作者又开始维护 tun 包，因此 此时 tun 包就更新了。
+
+tun 包在 windows 平台使用 wintun, 而在 其它平台使用 系统调用。
+
+经测试发现，windows 上的 wintun 性能很强，而在其它平台则用起来很卡顿，也许是平台问题，
+也许是tun 包的 异步实现代码的问题。
+
+smoltcp 的实现 在实践中比 lwip 实现快一些。因此 ruci-cmd 只采用了 smoltcp 的网络栈。
+
 
 # lib note
 
@@ -357,6 +385,9 @@ quinn (代码在 rucimp/src/map/quinn):全没问题
 
 而且 s2n-quic 在 windows 无法编译通过
 
+
+
+
 ## 编译运行问题
 
 tproxy,tun 要使用 管理员权限 运行

rucimp/src/map/tcp_ip_stack_smoltcp/device.rs

@@ -488,7 +488,7 @@ impl SmoltcpDevice {
                             network: Network::UDP,
                         };
 
-                        let ac = super::udp2::new(sa, sh, read_rx, self.udp_write_data_tx.clone());
+                        let ac = super::udp::new(sa, sh, read_rx, self.udp_write_data_tx.clone());
 
                         //debug!("smoltcp got new udp connection {dst_ipe} {src_ipe}");
 
@@ -510,14 +510,14 @@ impl SmoltcpDevice {
 
     /// check timeout udp and remove from device's SocketSet
     pub fn udp_health_check(&mut self) {
-        debug!("udp_health_check");
+        // debug!("udp_health_check");
         let mut udp_src_to_remove = Vec::new();
 
         {
             let m = self.udp_read_data_tx_map.lock();
 
             for (src, sender) in m.iter() {
-                debug!("checking udp for {:?}", src);
+                // debug!("checking udp for {:?}", src);
                 if sender.is_closed() {
                     //debug!("udp_health_check got a closed");
                     udp_src_to_remove.push(src.to_owned());
@@ -545,12 +545,12 @@ impl SmoltcpDevice {
 
                 let so: &mut smoltcp::socket::tcp::Socket = self.tcp_sockets.get_mut(h);
 
-                debug!(
-                    "checking {h}, {:?}, {:?} {}",
-                    so.local_endpoint(),
-                    so.remote_endpoint(),
-                    so.state()
-                );
+                // debug!(
+                //     "checking {h}, {:?}, {:?} {}",
+                //     so.local_endpoint(),
+                //     so.remote_endpoint(),
+                //     so.state()
+                // );
                 if !so.can_recv() {
                     debug!("cant recv {h}");
                 }
@@ -572,13 +572,13 @@ impl SmoltcpDevice {
                     let tcp_stream_read_data_sender = m.get(&h).unwrap();
 
                     if tcp_stream_read_data_sender.is_closed() {
-                        debug!("{h}, will delete tcp because sender closed");
+                        // debug!("{h}, will delete tcp because sender closed");
                         tcp_handles_to_remove.push(h);
                         tcp_src_to_remove.push(src);
                     } else {
-                        if !so.can_recv() {
-                            debug!("{h}, has src but cant recv, {}", so.state());
-                        }
+                        // if !so.can_recv() {
+                        //     debug!("{h}, has src but cant recv, {}", so.state());
+                        // }
 
                         while so.can_recv() && tcp_stream_read_data_sender.capacity() > 0 {
                             let mut buffer = BytesMut::with_capacity(so.recv_queue());
@@ -602,16 +602,16 @@ impl SmoltcpDevice {
                                     break;
                                 }
                             } else {
-                                debug!("tcp_read_data_tx so.recv_slice failed");
+                                // debug!("tcp_read_data_tx so.recv_slice failed");
                                 so.close();
                                 break;
                             }
                         }
                         if so.state() == State::CloseWait && so.send_queue() == 0 {
-                            debug!(
-                                "{h}, so.state() == State::CloseWait
-                                        && so.send_queue() == 0"
-                            );
+                            // debug!(
+                            //     "{h}, so.state() == State::CloseWait
+                            //             && so.send_queue() == 0"
+                            // );
                             let _ =
                                 tcp_stream_read_data_sender.try_send(BytesMut::with_capacity(0));
                             //这里将令 TcpStream 的 read端 收到一个 0字节，表示EOF

rucimp/src/map/tcp_ip_stack_smoltcp/mod.rs

@@ -4,7 +4,7 @@ Defines a [`Map`] called [`Stack`] using user level tcp/ip stack based on `smolt
 pub mod device;
 pub mod ip_packet;
 pub mod tcp;
-pub mod udp2;
+pub mod udp;
 
 use std::time::Duration;
 

rucimp/src/map/tcp_ip_stack_smoltcp/tcp.rs

@@ -96,13 +96,13 @@ impl AsyncRead for TcpReadHalf {
             let dst_buffer = buf.initialize_unfilled();
             let len = dst_buffer.len().min(me.buf.len());
 
-            debug!("smoltcp tcp read got len {len}");
+            // debug!("smoltcp tcp read got len {len}");
             let _ = &dst_buffer[..len].copy_from_slice(&me.buf.as_ref()[..len]);
             me.buf.advance(len);
             buf.set_filled(buf.filled().len() + len);
             Poll::Ready(Ok(()))
         } else if let Some(data) = ready!(me.rx.poll_recv(cx)) {
-            debug!("smoltcp tcp poll ready, got data {}", data.len());
+            // debug!("smoltcp tcp poll ready, got data {}", data.len());
             if data.is_empty() {
                 return Poll::Ready(Ok(()));
             }
@@ -137,7 +137,7 @@ impl AsyncWrite for TcpWriteHalf {
     }
 
     fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {
-        debug!("smoltcp tcp shutdown called");
+        // debug!("smoltcp tcp shutdown called");
         self.poll_write(cx, &[]).map(|ret| ret.map(|_| ()))
     }
 }
@@ -150,7 +150,7 @@ impl AsyncRead for TcpStream {
     ) -> Poll<std::io::Result<()>> {
         let me = self.get_mut();
         if me.is_closed {
-            debug!("smoltcp read got is closed");
+            // debug!("smoltcp read got is closed");
             return Poll::Ready(Ok(()));
         }
         Pin::new(&mut me.r).poll_read(cx, buf)
@@ -171,7 +171,7 @@ impl AsyncWrite for TcpStream {
         Pin::new(&mut me.w).poll_flush(cx)
     }
     fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {
-        debug!("smoltcp tcpstream shutdown called");
+        // debug!("smoltcp tcpstream shutdown called");
         let me = self.get_mut();
         me.is_closed = true;
         me.r.rx.close();