girl 0.54.0 → 0.55.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19acd0601b223880d31ac0294928830d0a683e419bce6da31712914bebc7b65d
-  data.tar.gz: 8b112d1eec1f6a83851e8b12e546217c8aeb59f9c743e56d600a23c2f5fc333e
+  metadata.gz: 98deb3d9378bcd1eb4477e0a6466c527770b957f627908fd2f6b696da6648083
+  data.tar.gz: f3bca1da27d757810adccb9bb20d3eddfbfdb7b5ea4e1d0c5130d956d0dbd059
 SHA512:
-  metadata.gz: d9bc77923d0a6e1637cd3b29c2f15aca7d882bf7b6b7501c51cf0fac529244e63e2ce4f8ca47594886d598479eaf3f545801a9f5fdb5fd00075a520cd69db86f
-  data.tar.gz: e57bdec56fb691207a9f4c1d47622c0f64ef9d4d3b703afba745281e41c50ae84825809af59fc84b1740eceb525a063b8ed3be130295af3725751518c9c44b3e
+  metadata.gz: 14d229048ad6c27df19295600b0c0817962b667bde195fd26a272a323d29b8f35196f49fc41cfc3b47afaac9f32e5e7d56be8dd890300a6d408e4a1a0fc600b5
+  data.tar.gz: de9f1a2af41e00056fb0822348276b5fcfd6326fe5b00813cc0f7bba66e2e7b524ad2a3f00d0e93d68723f14e4d4284a5f89f0e10564505c44e0d8a14ceee496

data/lib/girl/udp.rb

@@ -13,42 +13,44 @@ require 'socket'
 #
 # iptables -t nat -A PREROUTING -p udp -d game.server.ip -j REDIRECT --to-ports 1313
 #
-# control message
-# ================
+# p2p flow
+# =========
 #
-# C: 1 (tun > udpd: req a tund) -> orig_src_addr -> dest_addr
-# C: 2 (udpd > tun: tund port) -> n: tund_port -> tun_addr
-# C: 3 (udpd > tun: req a chain tun) -> new_dest_addr -> root_dest_addr
-# C: 4 (tun > udpd: req a chain tund) -> orig_src_addr -> dest_addr -> root_dest_addr
-# C: 5 (tun > tund: hello)
+# 源地址src发往第二个目的地dst2，iptables会映射一个新的本地端口sport2，用来代理dst2的返程。
+# 可在nf_conntrack里找到src1和src2，看到映射前的源地址端口是一样的。
+# 若在sport2没有收到返程30秒过期后，src发往第三个目的地dst3，iptables会把dst3的返程依旧映射在sport2上。因此不能根据映射端口建tun-tund对。
 #
-# flow
-# =====
+# tund1接到dst2，看作p2p进来，记tund1为src-dst2发送代理。
+# 取接收者tund1.dst2.receiver，由接收者接数据。
+# 若接收者为空，据dst2-src找接收者，找到tund2，tund2-tun2传数据，同时tund1发tund2.wmems去dst2。没找到，记tund1.dst2.rbuff。
 #
-# src从本机端口发出，发往两个目的地：
+# src经tun2-tund2发往dst2，记tund2为dst2-src接收者。
+# 取发送代理tund2.alias_sender，由发送代理发数据。
+# 若发送代理为空，据src-dst2找发送代理，找到tund1，tund1发数据给dst2，同时tund2转tund1.dst2.rbuffs给tun2。没找到，tund2-dst2，记tund2.wmem。
 #
-# src1=redir.recv -> new tun1 -> ctlmsg.1 -> udpd.recv -> new tund1 -> tund1.recv -> dst1
-# src2=redir.recv -> new tun2 -> ctlmsg.1 -> udpd.recv -> new tund2 -> tund2.recv -> dst2
+# 请求匹配服务器：
 #
-# src发往dst2，iptables会映射一个新的端口src2用来代理dst2的返程。可以在nf_conntrack里找到转换前的原端口，看到src2和src1是一样的。
+# redir recv -> src1, dst1, data -> tun1-tund1 data -> set receiver dst1-src: tund1 -> tund1-dst1 data
 #
-# p2p对面先到:
+# 匹配服务器返回：
 #
-# dst3=tund1.recv -> ctlmsg.3 -> tun1.recv -> new tun3 -> ctlmsg.4 -> udpd.recv -> new tund3 -> tun3.recv -> tun3.dest_rbuffs
-#   -> src3=redir.recv -> tun3=tuns.find([:orig_src dst3]) -> redir.wbuffs.append(tun3.dest_rbuffs) -> redir.send_to(src3)
+# tund1 recv -> dst1, data -> tund1-tun1 data -> redir-src1 data
 #
-# p2p对面先到的情况，准备好tun3-tund3，一边redir接到src3，根据[转换前地址 目的地]，匹中tun3。
+# p1发往p2：
 #
-# 来自对面的数据，先存在tund1身上，再移给tun3，src3匹中tun3后，移给redir写入src3。
+# redir recv -> src2, dst2, data -> tun2-tund2 data -> set receiver dst2-src: tund2 -> alias sender not found -> tund2-dst2 data -> save wmem
 #
-# p2p自己先出去：
+# p2后进来：
 #
-# src2=redir.recv -> new tun2 -> ctlmsg.1 -> udpd.recv -> new tund2 -> tund2.recv -> tund2.send_to(dst2) -> 撞死
-#   -> dst2=tund1.recv -> tund2=tunds.find(tun1_ip-orig_src-dst2) -> tun2.recv -> redir.send_to(src2)
+# tund1 recv -> dst2, data -> set alias sender src-dst2: tund1 -> found receiver tund2 -> tund2-tun2 redir-src2 data -> tund1-dst2 tund2.wmems
 #
-# p2p自己先出去的情况，包会撞死，并且这时还不知道tun2-tund2转发的是p2p流量。不用知道，先把发出的包缓存一下（存最后一个就行，一般是连发打洞的数据）。
+# p3进来：
 #
-# 一边tund1接到dst2，根据[:tun_ip :orig_src dst2]，匹中tund2。这时知道了tund2是p2p，由tund1代之和dst2通信（先把缓存的最后一个包发过去）。
+# tund1 recv -> dst3, data -> set alias sender src-dst3: tund1 -> receiver not found -> save data to tund1.dst3.rbuffs
+#
+# p1后发往p3：
+#
+# redir recv -> src3, dst3, data -> tun3-tund3 data -> set receiver dst3-src: tund3 -> found alias sender tund1 -> tund1-dst3 data -> tund3-tun3 redir-src tund1.dst3.rbuffs
 #
 module Girl
   class Udp
@@ -74,16 +76,15 @@ module Girl
         redir => :redir
       }
       @redir_wbuffs = [] # [ src_addr data ] ...
-      @tuns = {}         # [ orig_src_addr dest_addr ] => tun
+      @tuns = {}         # [ orig_src_addr dst_addr ]=> tun
+      @mappings = {}     # src_addr => [ orig_src_addr dst_addr ]
       @tun_infos = {}    # tun => {}
                          #   orig_src_addr: sockaddr
-                         #   dest_addr: sockaddr
+                         #   dst_addr: sockaddr
                          #   src_addr: sockaddr
-                         #   tun_addr: sockaddr
                          #   tund_addr: sockaddr
                          #   ctlmsgs: []
                          #   wbuffs: []
-                         #   dest_rbuffs: []
                          #   last_traff_at: now
     end
 
@@ -143,41 +144,34 @@ module Girl
       rows = bin.split( "\n" ).map { | line | line.split( ' ' ) }
       row = rows.find { | _row | _row[ 2 ] == 'udp' && ( ( _row[ 9 ] == '[UNREPLIED]' && _row[ 11 ].split( '=' )[ 1 ] == addrinfo.ip_address && _row[ 13 ].split( '=' )[ 1 ].to_i == addrinfo.ip_port ) || ( _row[ 10 ].split( '=' )[ 1 ] == addrinfo.ip_address && _row[ 12 ].split( '=' )[ 1 ].to_i == addrinfo.ip_port ) ) }
 
-      unless row
-        puts "miss conntrack #{ addrinfo.inspect } #{ Time.new }"
-        IO.binwrite( '/tmp/nf_conntrack', bin )
-        return
-      end
-
-      orig_src_ip = row[ 5 ].split( '=' )[ 1 ]
-      orig_src_port = row[ 7 ].split( '=' )[ 1 ].to_i
-      dest_ip = row[ 6 ].split( '=' )[ 1 ]
-      dest_port = row[ 8 ].split( '=' )[ 1 ].to_i
-      orig_src_addr = Socket.sockaddr_in( orig_src_port, orig_src_ip )
-      dest_addr = Socket.sockaddr_in( dest_port, dest_ip )
-      tun = @tuns[ [ orig_src_addr, dest_addr ].join ]
+      if row
+        orig_src_ip = row[ 5 ].split( '=' )[ 1 ]
+        orig_src_port = row[ 7 ].split( '=' )[ 1 ].to_i
+        dst_ip = row[ 6 ].split( '=' )[ 1 ]
+        dst_port = row[ 8 ].split( '=' )[ 1 ].to_i
+        orig_src_addr = Socket.sockaddr_in( orig_src_port, orig_src_ip )
+        dst_addr = Socket.sockaddr_in( dst_port, dst_ip )
+      else
+        unless @mappings.include?( src_addr )
+          puts "miss conntrack #{ addrinfo.inspect } #{ Time.new }"
+          IO.binwrite( '/tmp/nf_conntrack', bin )
+          return
+        end
 
-      if tun
-        tun_info = @tun_infos[ tun ]
+        puts "hit mapping #{ addrinfo.inspect }"
+        orig_src_addr, dst_addr = @mappings[ src_addr ]
+      end
 
-        unless tun_info[ :src_addr ]
-          # p2p paired
-          tun_info[ :src_addr ] = src_addr
+      tun = @tuns[ [ orig_src_addr, dst_addr ].join ]
 
-          if tun_info[ :dest_rbuffs ].any?
-            # puts "debug move dest_rbuff to redir #{ Addrinfo.new( tun_info[ :dest_addr ] ).inspect } #{ Addrinfo.new( tun_info[ :orig_src_addr ] ).inspect }"
-            @redir_wbuffs += tun_info[ :dest_rbuffs ].map{ | buff | [ src_addr, buff ] }
-            tun_info[ :dest_rbuffs ].clear
-            add_redir_write( redir )
-          end
-        end
-      else
-        tun = new_a_tun( orig_src_addr, dest_addr, src_addr )
-        tun_info = @tun_infos[ tun ]
+      unless tun
+        tun = new_a_tun( orig_src_addr, dst_addr, src_addr )
 
-        # puts "debug send C: 1 (tun > udpd: req a tund) -> orig_src_addr dest_addr #{ Addrinfo.new( orig_src_addr ).inspect } #{ Addrinfo.new( dest_addr ).inspect }"
-        ctlmsg = [ [ 1 ].pack( 'C' ), orig_src_addr, dest_addr ].join
+        # puts "debug tun send to udpd #{ Addrinfo.new( orig_src_addr ).inspect } #{ Addrinfo.new( dst_addr ).inspect }"
+        ctlmsg = [ orig_src_addr, dst_addr ].join
         add_ctlmsg( tun, ctlmsg )
+
+        @mappings[ src_addr ] = [ orig_src_addr, dst_addr ]
       end
 
       add_write( tun, data )
@@ -190,46 +184,13 @@ module Girl
       tun_info[ :last_traff_at ] = Time.new
 
       if from_addr == @udpd_addr
-        ctl_num = data[ 0 ].unpack( 'C' ).first
-
-        case ctl_num
-        when 2 # C: 2 (udpd > tun: tund port) -> n: tund_port -> tun_addr
-          return if tun_info[ :tund_addr ]
-
-          tund_port = data[ 1, 2 ].unpack( 'n' ).first
-          tun_addr = data[ 3, 16 ]
-          tund_addr = Socket.sockaddr_in( tund_port, @udpd_host )
-          tun_info[ :tun_addr ] = tun_addr
-          tun_info[ :tund_addr ] = tund_addr
-
-          # flush wbuffs to tund, if empty, just send a cross nat msg (5: hello), tund should ignore hello
-          if tun_info[ :wbuffs ].empty?
-            tun_info[ :wbuffs ] << [ 5 ].pack( 'C' )
-          end
-
-          add_write( tun )
-        when 3 # C: 3 (udpd > tun: req a chain tun) -> new_dest_addr -> root_dest_addr
-          new_dest_addr = data[ 1, 16 ]
-          root_dest_addr = data[ 17, 16 ]
-          orig_src_addr = tun_info[ :orig_src_addr ]
-          chain_tun = @tuns[ [ orig_src_addr, new_dest_addr ].join ]
-
-          unless chain_tun
-            chain_tun = new_a_tun( orig_src_addr, new_dest_addr )
-          end
-
-          # puts "debug send C: 4 (tun > udpd: req a chain tund) -> orig_src_addr -> dest_addr -> root_dest_addr #{ Addrinfo.new( orig_src_addr ).inspect } #{ Addrinfo.new( new_dest_addr ).inspect } #{ Addrinfo.new( root_dest_addr ).inspect }"
-          ctlmsg = [ [ 4 ].pack( 'C' ), orig_src_addr, new_dest_addr, root_dest_addr ].join
-          add_ctlmsg( chain_tun, ctlmsg )
-        end
+        tund_port = data[ 0, 2 ].unpack( 'n' ).first
+        tund_addr = Socket.sockaddr_in( tund_port, @udpd_host )
+        tun_info[ :tund_addr ] = tund_addr
+        add_write( tun )
       elsif from_addr == tun_info[ :tund_addr ]
-        if tun_info[ :src_addr ]
-          @redir_wbuffs << [ tun_info[ :src_addr ], data ]
-          add_redir_write( @redir )
-        else
-          # puts "debug save to tun.dest_rbuffs #{ data.inspect }"
-          tun_info[ :dest_rbuffs ] << data
-        end
+        @redir_wbuffs << [ tun_info[ :src_addr ], data ]
+        add_write( @redir )
       end
     end
 
@@ -269,27 +230,17 @@ module Girl
     def add_ctlmsg( tun, ctlmsg )
       tun_info = @tun_infos[ tun ]
       tun_info[ :ctlmsgs ] << ctlmsg
-
-      unless @writes.include?( tun )
-        @writes << tun
-      end
+      add_write( tun )
     end
 
-    def add_write( tun, data = nil )
-      tun_info = @tun_infos[ tun ]
-
+    def add_write( sock, data = nil )
       if data
+        tun_info = @tun_infos[ sock ]
         tun_info[ :wbuffs ] << data
       end
 
-      unless @writes.include?( tun )
-        @writes << tun
-      end
-    end
-
-    def add_redir_write( redir )
-      unless @writes.include?( redir )
-        @writes << redir
+      unless @writes.include?( sock )
+        @writes << sock
       end
     end
 
@@ -308,27 +259,33 @@ module Girl
       @closings.delete( tun )
       @roles.delete( tun )
       tun_info = @tun_infos.delete( tun )
-      @tuns.delete( [ tun_info[ :orig_src_addr ], tun_info[ :dest_addr ] ].join )
+      @tuns.delete( [ tun_info[ :orig_src_addr ], tun_info[ :dst_addr ] ].join )
+
+      if @mappings.include?( tun_info[ :src_addr ] )
+        orig_src_addr, dst_addr = @mappings[ tun_info[ :src_addr ] ]
+
+        if orig_src_addr == tun_info[ :orig_src_addr ] && dst_addr == tun_info[ :dst_addr ]
+          @mappings.delete( tun_info[ :src_addr ] )
+        end
+      end
     end
 
-    def new_a_tun( orig_src_addr, dest_addr, src_addr = nil )
+    def new_a_tun( orig_src_addr, dst_addr, src_addr )
       tun = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
       tun.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
       tun.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
 
-      @tuns[ [ orig_src_addr, dest_addr ].join ] = tun
       @tun_infos[ tun ] = {
         orig_src_addr: orig_src_addr,
-        dest_addr: dest_addr,
+        dst_addr: dst_addr,
         src_addr: src_addr,
-        tun_addr: nil,
         tund_addr: nil,
         ctlmsgs: [],
         wbuffs: [],
-        dest_rbuffs: [],
         last_traff_at: Time.new
       }
 
+      @tuns[ [ orig_src_addr, dst_addr ].join ] = tun
       @roles[ tun ] = :tun
       @reads << tun
 
@@ -344,8 +301,8 @@ module Girl
             now = Time.new
 
             @tun_infos.values.each do | tun_info |
-              if now - tun_info[ :last_traff_at ] > 1800
-                @ctlw.write( [ tun_info[ :orig_src_addr ], tun_info[ :dest_addr ] ].join )
+              if now - tun_info[ :last_traff_at ] > 600
+                @ctlw.write( [ tun_info[ :orig_src_addr ], tun_info[ :dst_addr ] ].join )
               end
             end
           end

data/lib/girl/udpd.rb

@@ -26,19 +26,19 @@ module Girl
         udpd => :udpd
       }
       @udpd_wbuffs = []       # [ tun_addr ctlmsg ] ...
-      @tunds = {}             # [ tun_ip_addr orig_src_addr dest_addr ] => tund
+      @tunds = {}             # tun_addr => tund
+      @alias_senders = {}     # [ tun_ip_addr orig_src_addr dst_addr ] => tund # alias senders to dst
+      @receivers = {}         # [ dst_addr tun_ip_addr orig_src_addr ] => tund # receivers from dst
       @tund_infos = {}        # tund => {}
                               #   port: port
-                              #   is_tunneled: false
                               #   tun_addr: sockaddr
                               #   tun_ip_addr: sockaddr
                               #   orig_src_addr: sockaddr
-                              #   dest_addr: sockaddr
-                              #   root_tund: tund1
-                              #   wbuffs: []
-                              #   is_dest_responsed: false
-                              #   dest_wmemos: []
-                              #   new_dest_rbuffs: { new_dest_addr => [] }
+                              #   dst_addr: sockaddr
+                              #   wbuffs: [] # 写往tun的写前缓存
+                              #   wmems: [] # 写往dst的写后缓存
+                              #   other_dst_rbuffs: { new_dst_addr => [] }
+                              #   receivers: { other_dst_addr => other_tund }
                               #   last_traff_at: now
       @od_addr_rbuffs = {}
     end
@@ -80,8 +80,8 @@ module Girl
     private
 
     def read_ctlr( ctlr )
-      tod_addr = ctlr.read( 48 )
-      tund = @tunds[ tod_addr ]
+      tun_addr = ctlr.read( 16 )
+      tund = @tunds[ tun_addr ]
 
       if tund
         add_closing( tund )
@@ -89,54 +89,29 @@ module Girl
     end
 
     def read_udpd( udpd )
-      # C: 1 (tun > udpd: req a tund) -> orig_src_addr -> dest_addr
-      # C: 4 (tun > udpd: req a chain tund) -> orig_src_addr -> dest_addr -> root_dest_addr
       data, addrinfo, rflags, *controls = udpd.recvmsg
       # puts "debug udpd recv #{ data.inspect } from #{ addrinfo.inspect }"
-      ctl_num = data[ 0 ].unpack( 'C' ).first
-      orig_src_addr = data[ 1, 16 ]
-      dest_addr = data[ 17, 16 ]
+      orig_src_addr = data[ 0, 16 ]
+      dst_addr = data[ 16, 16 ]
       tun_addr = addrinfo.to_sockaddr
       tun_ip_addr = Addrinfo.ip( addrinfo.ip_address ).to_sockaddr
 
-      return unless [ 1, 4 ].include?( ctl_num )
       return unless Addrinfo.new( orig_src_addr ).ipv4?
-      return unless Addrinfo.new( dest_addr ).ipv4?
+      return unless Addrinfo.new( dst_addr ).ipv4?
 
-      tund = @tunds[ [ tun_ip_addr, orig_src_addr, dest_addr ].join ]
+      tund = @tunds[ tun_addr ]
 
-      if ctl_num == 1
-        unless tund
-          tund = new_a_tund( tun_addr, tun_ip_addr, orig_src_addr, dest_addr )
-        end
-      elsif ctl_num == 4
-        root_dest_addr = data[ 33, 16 ]
-        return unless Addrinfo.new( root_dest_addr ).ipv4?
-
-        root_tund = @tunds[ [ tun_ip_addr, orig_src_addr, root_dest_addr ].join ]
-
-        unless root_tund
-          puts "miss root tund? #{ Addrinfo.new( tun_ip_addr ).inspect } #{ Addrinfo.new( orig_src_addr ).inspect } #{ Addrinfo.new( root_dest_addr ).inspect }"
-          return
-        end
-
-        if tund
-          tund_info = @tund_infos[ tund ]
-          tund_info[ :root_tund ] = root_tund
-        else
-          tund = new_a_tund( tun_addr, tun_ip_addr, orig_src_addr, dest_addr, root_tund )
-        end
+      unless tund
+        tund = new_a_tund( tun_addr, tun_ip_addr, orig_src_addr, dst_addr )
       end
 
       tund_info = @tund_infos[ tund ]
       tund_port = tund_info[ :port ]
 
-      # puts "debug send C: 2 (udpd > tun: tund port) -> n: tund_port -> tun_addr #{ tund_port } #{ addrinfo.inspect }"
-      @udpd_wbuffs << [ tun_addr, [ [ 2, tund_port ].pack( 'Cn' ), tun_addr ].join ]
-
-      unless @writes.include?( udpd )
-        @writes << udpd
-      end
+      # puts "debug udpd send to tun #{ tund_port } #{ addrinfo.inspect }"
+      ctlmsg = [ tund_port ].pack( 'n' )
+      @udpd_wbuffs << [ tun_addr, ctlmsg ]
+      add_write( udpd )
     end
 
     def read_tund( tund )
@@ -145,78 +120,105 @@ module Girl
       tund_info = @tund_infos[ tund ]
       tund_info[ :last_traff_at ] = Time.new
 
-      if from_addr == tund_info[ :tun_addr ]
-        root_tund = tund_info[ :root_tund ]
+      case from_addr
+      when tund_info[ :tun_addr ]
+        # src经tun2-tund2发往dst2，记tund2为dst2-src接收者。
+        dto_addr = [ tund_info[ :dst_addr ], tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ] ].join
 
-        if !tund_info[ :is_tunneled ]
-          tund_info[ :is_tunneled ] = true
+        if @receivers[ dto_addr ]
+          if @receivers[ dto_addr ] != tund
+            puts "receiver not unique? #{ Addrinfo.new( tund_info[ :dst_addr ] ).inspect } #{ Addrinfo.new( tund_info[ :tun_ip_addr ] ).inspect } #{ Addrinfo.new( tund_info[ :orig_src_addr ] ).inspect }"
+            return
+          end
+        else
+          @receivers[ dto_addr ] = tund
+        end
+
+        # 取发送代理tund2.alias_sender，由发送代理发数据。
+        sender = tund_info[ :alias_sender ]
+
+        if sender
+          # puts "debug alias sender send #{ data.inspect } to #{ Addrinfo.new( tund_info[ :dst_addr ] ).inspect }"
+          sender.sendmsg( data, 0, tund_info[ :dst_addr ] )
+        else
+          # 若发送代理为空，据src-dst2找发送代理，找到tund1，tund1发数据给dst2，同时tund2转tund1.dst2.rbuffs给tun2。没找到，tund2-dst2，记tund2.wmem。
+          tod_addr = [ tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ], tund_info[ :dst_addr ] ].join
+          sender = @alias_senders[ tod_addr ]
 
-          if root_tund
-            # p2p tunnel paired
-            root_tund_info = @tund_infos[ root_tund ]
-            dest_rbuffs = root_tund_info[ :new_dest_rbuffs ].delete( tund_info[ :dest_addr ] )
+          if sender
+            sender.sendmsg( data, 0, tund_info[ :dst_addr ] )
+            tund_info[ :alias_sender ] = sender
 
-            if dest_rbuffs
-              # puts "debug #{ Addrinfo.new( tund_info[ :dest_addr ] ).inspect } dest_rbuffs #{ dest_rbuffs.inspect }"
-              tund_info[ :wbuffs ] = dest_rbuffs
+            sender_info = @tund_infos[ sender ]
+            rbuffs = sender_info[ :other_dst_rbuffs ].delete( tund_info[ :dst_addr ] )
+
+            if rbuffs
+              # puts "debug move tund1.dst2.rbuffs to tund2.wbuffs #{ rbuffs.inspect }"
+              tund_info[ :wbuffs ] += rbuffs
               add_write( tund )
             end
+          else
+            tund.sendmsg( data, 0, tund_info[ :dst_addr ] )
 
-            if data.size == 1 && data[ 0 ].unpack( 'C' ).first == 5
-              puts "ignore C: 5 (hello) #{ Time.new }"
-              return
+            # 缓存写后，可能是p2p自己先出去，撞死的流量，之后对面进来匹配成对，由发送代理重发。超过5条看做非p2p。
+            if tund_info[ :wmems ].size < 5
+              # puts "debug save wmem #{ data.inspect } #{ Addrinfo.new( tund_info[ :dst_addr ] ).inspect }"
+              tund_info[ :wmems ] << data
             end
           end
         end
-
-        sender = root_tund || tund
-        sender.sendmsg( data, 0, tund_info[ :dest_addr ] )
-
-        if root_tund.nil? && !tund_info[ :is_dest_responsed ]
-          if tund_info[ :dest_wmemos ].size >= 10
-            tund_info[ :dest_wmemos ].clear
-          end
-
-          tund_info[ :dest_wmemos ] << data
-        end
-      elsif from_addr == tund_info[ :dest_addr ]
-        tund_info[ :is_dest_responsed ] = true
+      when tund_info[ :dst_addr ]
+        # puts "debug tund-tun #{ data.inspect } from #{ Addrinfo.new( tund_info[ :dst_addr ] ).inspect }"
         add_write( tund, data )
       else
-        # p2p input
-        # puts "debug tund recv #{ data.inspect } from #{ Addrinfo.new( from_addr ).inspect }"
-        chain_tund = @tunds[ [ tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ], from_addr ].join ]
-
-        unless chain_tund
-          unless tund_info[ :new_dest_rbuffs ].include?( from_addr )
-            tund_info[ :new_dest_rbuffs ][ from_addr ] = []
+        # tund1接到dst2，看作p2p进来，记tund1为src-dst2发送代理。
+        # puts "debug tund recv #{ data.inspect } from #{ addrinfo.inspect }"
+        tod_addr = [ tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ], from_addr ].join
+
+        if @alias_senders[ tod_addr ]
+          if @alias_senders[ tod_addr ] != tund
+            puts "alias sender not unique? #{ Addrinfo.new( tund_info[ :tun_ip_addr ] ).inspect } #{ Addrinfo.new( tund_info[ :orig_src_addr ] ).inspect } #{ addrinfo.inspect }"
+            return
           end
+        else
+          @alias_senders[ tod_addr ] = tund
+        end
 
-          tund_info[ :new_dest_rbuffs ][ from_addr ] << data
+        # 取接收者tund1.dst2.receiver，由接收者接数据。
+        receiver = tund_info[ :receivers ][ from_addr ]
 
-          # puts "debug send C: 3 (udpd > tun: req a chain tun) -> new_dest_addr -> root_dest_addr #{ Addrinfo.new( from_addr ).inspect } #{ Addrinfo.new( tund_info[ :dest_addr ] ).inspect }"
-          msg = [ [ 3 ].pack( 'C' ), from_addr, tund_info[ :dest_addr ] ].join
-          @udpd.sendmsg( msg, 0, tund_info[ :tun_addr ] )
-          return
-        end
+        if receiver
+          receiver_info = @tund_infos[ receiver ]
+          add_write( receiver, data )
+        else
+          # 若接收者为空，据dst2-src找接收者，找到tund2，tund2-tun2传数据，同时tund1转tund2.wmems给dst2。没找到，记tund1.dst2.rbuff。
+          dto_addr = [ from_addr, tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ] ].join
+          receiver = @receivers[ dto_addr ]
 
-        chain_tund_info = @tund_infos[ chain_tund ]
+          if receiver
+            add_write( receiver, data )
 
-        unless chain_tund_info[ :root_tund ]
-          # p2p paired
-          chain_tund_info[ :root_tund ] = tund
+            tund_info[ :receivers ][ from_addr ] = receiver
+            receiver_info = @tund_infos[ receiver ]
 
-          if chain_tund_info[ :dest_wmemos ].size > 0
-            chain_tund_info[ :dest_wmemos ].each do | wmemo |
-              # puts "debug send wmemo #{ wmemo.inspect } to #{ Addrinfo.new( from_addr ).inspect }"
-              tund.sendmsg( wmemo, 0, from_addr )
+            receiver_info[ :wmems ].each do | wmem |
+              # puts "debug send wmem #{ wmem.inspect } to #{ addrinfo.inspect }"
+              tund.sendmsg( wmem, 0, from_addr )
             end
 
-            chain_tund_info[ :dest_wmemos ].clear
+            receiver_info[ :wmems ].clear
+          else
+            unless tund_info[ :other_dst_rbuffs ][ from_addr ]
+              tund_info[ :other_dst_rbuffs ][ from_addr ] = []
+            end
+
+            # 暂存对面先到的p2p流量。超过5条看做意外数据忽略。
+            if tund_info[ :other_dst_rbuffs ][ from_addr ].size < 5
+              # puts "debug save other dst rbuff #{ addrinfo.inspect } #{ data.inspect }"
+              tund_info[ :other_dst_rbuffs ][ from_addr ] << data
+            end
           end
         end
-
-        add_write( chain_tund, data )
       end
     end
 
@@ -247,15 +249,14 @@ module Girl
       tund.sendmsg( data, 0, tund_info[ :tun_addr ] )
     end
 
-    def add_write( tund, data = nil )
-      tund_info = @tund_infos[ tund ]
-
+    def add_write( sock, data = nil )
       if data
+        tund_info = @tund_infos[ sock ]
         tund_info[ :wbuffs ] << data
       end
 
-      if tund_info[ :tun_addr ] && !@writes.include?( tund )
-        @writes << tund
+      unless @writes.include?( sock )
+        @writes << sock
       end
     end
 
@@ -274,28 +275,39 @@ module Girl
       @closings.delete( tund )
       @roles.delete( tund )
       tund_info = @tund_infos.delete( tund )
-      @tunds.delete( [ tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ], tund_info[ :dest_addr ] ].join )
+      @tunds.delete( tund_info[ :tun_addr ] )
+
+      tod_addr = [ tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ], tund_info[ :dst_addr ] ].join
+
+      if @alias_senders[ tod_addr ] && @alias_senders[ tod_addr ] == tund
+        @alias_senders.delete( tod_addr )
+      end
+
+      dto_addr = [ tund_info[ :dst_addr ], tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ] ].join
+
+      if @receivers[ dto_addr ] && @receivers[ dto_addr ] == tund
+        @receivers.delete( dto_addr )
+      end
     end
 
-    def new_a_tund( tun_addr, tun_ip_addr, orig_src_addr, dest_addr, root_tund = nil )
+    def new_a_tund( tun_addr, tun_ip_addr, orig_src_addr, dst_addr )
       tund = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
       tund.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
+      tund.setsockopt( Socket::SOL_SOCKET, Socket::SO_BROADCAST, 1 )
       tund.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
       tund_port = tund.local_address.ip_unpack.last
 
-      @tunds[ [ tun_ip_addr, orig_src_addr, dest_addr ].join ] = tund
+      @tunds[ tun_addr ] = tund
       @tund_infos[ tund ] = {
         port: tund_port,
-        is_tunneled: false,
         tun_addr: tun_addr,
         tun_ip_addr: tun_ip_addr,
         orig_src_addr: orig_src_addr,
-        dest_addr: dest_addr,
-        root_tund: root_tund,
+        dst_addr: dst_addr,
         wbuffs: [],
-        is_dest_responsed: root_tund ? true : false,
-        dest_wmemos: [],
-        new_dest_rbuffs: {},
+        wmems: [],
+        other_dst_rbuffs: {},
+        receivers: {},
         last_traff_at: Time.new
       }
 
@@ -314,8 +326,8 @@ module Girl
             now = Time.new
 
             @tund_infos.values.each do | tund_info |
-              if now - tund_info[ :last_traff_at ] > 1800
-                @ctlw.write(  [ tund_info[ :tun_ip_addr ], tund_info[ :orig_src_addr ], tund_info[ :dest_addr ] ].join )
+              if now - tund_info[ :last_traff_at ] > 600
+                @ctlw.write( tund_info[ :tun_addr ] )
               end
             end
           end

data/lib/girl/version.rb

@@ -1,3 +1,3 @@
 module Girl
-  VERSION = '0.54.0'.freeze
+  VERSION = '0.55.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: girl
 version: !ruby/object:Gem::Version
-  version: 0.54.0
+  version: 0.55.0
 platform: ruby
 authors:
 - takafan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-02 00:00:00.000000000 Z
+date: 2020-04-06 00:00:00.000000000 Z
 dependencies: []
 description: while internet is evil, here's a girl.
 email: