修订文档,代码;实现tun的udp部分,未经测试

README.md

@@ -21,7 +21,7 @@ telegram channel: https://t.me/+r5hKQKYyeuowMTcx
 
 verysimple， 实际上 谐音来自 V2ray Simple (显然只适用于汉语母语者), 意思就是极简.
 
-verysimple 是一个 代理内核, 对标 v2ray/xray，功能较为丰富，轻量级，极简，用户友好，新手向。
+verysimple 是一个 代理内核, 对标 v2ray/xray，功能较为丰富，轻量级，极简，用户友好，新手向。以学习编程技术为主要目标。
 
 本作的想法是，使用自己的代码，实现v2ray的所有的好的功能（并摒弃差的功能），而且使用自主研发的更简单的架构，结合自主研发的新技术，实现反超。
 
@@ -34,6 +34,10 @@ verysimple项目大大简化了 转发机制，能提高运行速度。本项目
 verysimple 研发了一些新技术，使用自研架构，可以加速，目前基本上是全网最快，且有用户报告内存占用 比v2ray/xray 小1/3。
 
 vs的一些亮点是 全协议readv加速，lazy技术，vless v1，hysteria 阻控，更广泛的utls支持，grpc回落，交互模式等。
+
+总的来说，代理的编写是一个非常简单的事情，属于平民级别。
+只要不涉及复杂的tls、tcp、ip原始协议的解析，不涉及新代理协议的制定，只是制作一款代理是相当容易的。
+
 ## 支持的功能
 
 socks5(包括 udp associate 以及用户密码)/http(以及用户密码)/socks5http(与clash的mixed等价)/dokodemo/tproxy(透明代理)/trojan/simplesocks/vless(v0/**v1**)/vmess/shadowsocks, 多用户, http头

examples/tun.client.toml

@@ -22,6 +22,8 @@
 # sudo route delete -host default
 # sudo route add default 192.168.1.1
 
+# 你还可以参考 https://github.com/yangchuansheng/love-gfw/blob/master/docs/gotun2socks-macos.md
+
 
 [[listen]]
 protocol = "tun"

netLayer/tun/tun.go

@@ -16,15 +16,28 @@ import (
 type coreUDPConnAdapter struct {
 	core.UDPConn
 	netLayer.EasyDeadline
+
+	readChan chan netLayer.UDPAddrData
+}
+
+func newUdpAdapter() *coreUDPConnAdapter {
+	c := new(coreUDPConnAdapter)
+	c.InitEasyDeadline()
+	c.readChan = make(chan netLayer.UDPAddrData, 1)
+	return c
 }
 
 func (h *coreUDPConnAdapter) ReadMsgFrom() ([]byte, netLayer.Addr, error) {
 
-	return nil, netLayer.Addr{}, nil
+	ud := <-h.readChan
+
+	return ud.Data, netLayer.NewAddrFromUDPAddr(&ud.Addr), nil
 }
-func (h *coreUDPConnAdapter) WriteMsgTo([]byte, netLayer.Addr) error {
-	return nil
+func (h *coreUDPConnAdapter) WriteMsgTo(data []byte, ad netLayer.Addr) error {
+	_, err := h.UDPConn.WriteFrom(data, ad.ToUDPAddr())
+	return err
 }
+
 func (h *coreUDPConnAdapter) CloseConnWithRaddr(raddr netLayer.Addr) error {
 
 	return nil
@@ -36,12 +49,15 @@ func (h *coreUDPConnAdapter) Fullcone() bool {
 type handler struct {
 	tcpChan chan netLayer.TCPRequestInfo
 	udpChan chan netLayer.UDPRequestInfo
+
+	udpmap map[netLayer.HashableAddr]*coreUDPConnAdapter
 }
 
 func newHandler() *handler {
 	return &handler{
 		tcpChan: make(chan netLayer.TCPRequestInfo),
 		udpChan: make(chan netLayer.UDPRequestInfo),
+		udpmap:  make(map[netLayer.HashableAddr]*coreUDPConnAdapter),
 	}
 }
 
@@ -54,23 +70,44 @@ func (h *handler) Handle(conn net.Conn, target *net.TCPAddr) error {
 }
 
 func (h *handler) Connect(conn core.UDPConn, target *net.UDPAddr) error {
-	uad := netLayer.NewAddrFromUDPAddr(target)
-	adapter := &coreUDPConnAdapter{UDPConn: conn}
-	adapter.InitEasyDeadline()
-
-	h.udpChan <- netLayer.UDPRequestInfo{Target: uad, MsgConn: adapter}
 	return nil
 }
 
 func (h *handler) ReceiveTo(conn core.UDPConn, data []byte, addr *net.UDPAddr) error {
-	log.Println("ReceiveTo called")
+	//log.Println("ReceiveTo called")
+
+	//这个conn是 tun的conn，我们只调用它的 WriteFrom 方法 把从外部获得的数据写入 tunDev
+
+	//也就是说，netLayer.MsgConn.ReadMsgFrom获得的数据要用 core.UDPConn.WriteFrom 写入
+
+	//tun 会调用我们的 ReceiveTo 方法 给我们新的 从tun读到的消息
+
+	uad := netLayer.NewAddrFromUDPAddr(addr)
+
+	ha := uad.GetHashable()
+	if adapter, ok := h.udpmap[ha]; ok {
+		adapter.readChan <- netLayer.UDPAddrData{Data: data, Addr: *addr}
+
+	} else {
+		adapter := newUdpAdapter()
+		adapter.UDPConn = conn
+
+		h.udpmap[ha] = adapter
+		adapter.readChan <- netLayer.UDPAddrData{Data: data, Addr: *addr}
+
+		h.udpChan <- netLayer.UDPRequestInfo{Target: uad, MsgConn: adapter}
+	}
+
 	return nil
 }
 
-func ListenTun() (tunDev io.ReadWriteCloser, err error) {
+// selfaddr是tun向外拨号时使用的ip; realAddr 是 tun接收数据时对外暴露的ip。
+// mask是子网掩码，不是很重要.
+// macos上的使用举例："", "10.1.0.10", "10.1.0.20", "255.255.255.0"
+func CreateTun(name, selfaddr, realAddr, mask string) (tunDev io.ReadWriteCloser, err error) {
 
 	//macos 上无法指定tun名称
-	tunDev, err = tun.OpenTunDevice("", "10.1.0.10", "10.1.0.20", "255.255.255.0", nil, false)
+	tunDev, err = tun.OpenTunDevice(name, selfaddr, realAddr, mask, nil, false)
 	if err == nil {
 		if ce := utils.CanLogInfo("created new tun device"); ce != nil {
 			ce.Write(zap.String("name", tunDev.(*water.Interface).Name()))
@@ -86,7 +123,7 @@ func ListenTun() (tunDev io.ReadWriteCloser, err error) {
 	return
 }
 
-func HandleTun(tunDev io.ReadWriteCloser) (tcpChan <-chan netLayer.TCPRequestInfo, udpChan <-chan netLayer.UDPRequestInfo, closer io.Closer) {
+func ListenTun(tunDev io.ReadWriteCloser) (tcpChan <-chan netLayer.TCPRequestInfo, udpChan <-chan netLayer.UDPRequestInfo, closer io.Closer) {
 	lwip := core.NewLWIPStack()
 	core.RegisterOutputFn(func(data []byte) (int, error) {
 		return tunDev.Write(data)

proxy/tun/tun.go

@@ -40,8 +40,9 @@ type Server struct {
 
 	stopped bool
 
-	infoChan   chan<- netLayer.TCPRequestInfo
-	lwipCloser io.Closer
+	infoChan       chan<- netLayer.TCPRequestInfo
+	udpRequestChan chan<- netLayer.UDPRequestInfo
+	lwipCloser     io.Closer
 }
 
 func (*Server) Name() string { return name }
@@ -63,33 +64,47 @@ func (s *Server) Stop() {
 		s.stopped = true
 		s.lwipCloser.Close()
 		close(s.infoChan)
+		close(s.udpRequestChan)
 	}
 
 }
 
-func (s *Server) StartListen(infoChan chan<- netLayer.TCPRequestInfo, udpInfoChan chan<- netLayer.UDPRequestInfo) io.Closer {
-	tunDev, err := tun.ListenTun()
+func (s *Server) StartListen(tcpRequestChan chan<- netLayer.TCPRequestInfo, udpRequestChan chan<- netLayer.UDPRequestInfo) io.Closer {
+	tunDev, err := tun.CreateTun("", "10.1.0.10", "10.1.0.20", "255.255.255.0")
 	if err != nil {
 		if ce := utils.CanLogErr("tun listen failed"); ce != nil {
 			ce.Write(zap.Error(err))
 		}
 		return nil
 	}
-	s.infoChan = infoChan
+	s.infoChan = tcpRequestChan
+	s.udpRequestChan = udpRequestChan
 
-	tchan, _, lwipcloser := tun.HandleTun(tunDev)
+	newTchan, newUchan, lwipcloser := tun.ListenTun(tunDev)
 	go func() {
-		for tr := range tchan {
+		for tr := range newTchan {
 			if s.stopped {
 				return
 			}
 			if ce := utils.CanLogInfo("tun got new tcp"); ce != nil {
 				ce.Write(zap.String("->", tr.Target.String()))
 			}
-			infoChan <- tr
+			tcpRequestChan <- tr
 
 		}
 	}()
+
+	go func() {
+		for ur := range newUchan {
+			if s.stopped {
+				return
+			}
+			if ce := utils.CanLogInfo("tun got new udp"); ce != nil {
+				ce.Write(zap.String("->", ur.Target.String()))
+			}
+			udpRequestChan <- ur
+		}
+	}()
 	s.lwipCloser = lwipcloser
 
 	return s