girl 0.53.0 → 0.54.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93fdfe2ce9f04aadda128b2ea4fa78d53370d240b7b8bf8ec7599a4269dce015
-  data.tar.gz: 8e4dd7830bd3575d7dbbd38c767b48d467cd135d7e804d4482ead4afd8d783d7
+  metadata.gz: 19acd0601b223880d31ac0294928830d0a683e419bce6da31712914bebc7b65d
+  data.tar.gz: 8b112d1eec1f6a83851e8b12e546217c8aeb59f9c743e56d600a23c2f5fc333e
 SHA512:
-  metadata.gz: b81316544189b48c6767010096eaa47df8a492b7f1e381945fee069af228fb6dfdf60e82b217a60292a40615fbbb0bea7e8448a8c57318ad628a698701ddc35e
-  data.tar.gz: d182a4d6509f321098520778d81b37189e29de591247239fbcc28027c974ca5647fc9a37c9a174dcfd1bf8510db8c60ae8316f4af9296f77aab9f87fb1726dbc
+  metadata.gz: d9bc77923d0a6e1637cd3b29c2f15aca7d882bf7b6b7501c51cf0fac529244e63e2ce4f8ca47594886d598479eaf3f545801a9f5fdb5fd00075a520cd69db86f
+  data.tar.gz: e57bdec56fb691207a9f4c1d47622c0f64ef9d4d3b703afba745281e41c50ae84825809af59fc84b1740eceb525a063b8ed3be130295af3725751518c9c44b3e

data/lib/girl/udp.rb

@@ -5,7 +5,7 @@ require 'socket'
 # Girl::Udp - 转发udp。近端。
 #
 # usage
-# =====
+# ======
 #
 # Girl::Udpd.new( 3030 ).looping # 远端
 #
@@ -13,6 +13,43 @@ require 'socket'
 #
 # iptables -t nat -A PREROUTING -p udp -d game.server.ip -j REDIRECT --to-ports 1313
 #
+# control message
+# ================
+#
+# 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)
+#
+# flow
+# =====
+#
+# src从本机端口发出，发往两个目的地：
+#
+# 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是一样的。
+#
+# 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)
+#
+# p2p对面先到的情况，准备好tun3-tund3，一边redir接到src3，根据[转换前地址 目的地]，匹中tun3。
+#
+# 来自对面的数据，先存在tund1身上，再移给tun3，src3匹中tun3后，移给redir写入src3。
+#
+# p2p自己先出去：
+#
+# 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)
+#
+# p2p自己先出去的情况，包会撞死，并且这时还不知道tun2-tund2转发的是p2p流量。不用知道，先把发出的包缓存一下（存最后一个就行，一般是连发打洞的数据）。
+#
+# 一边tund1接到dst2，根据[:tun_ip :orig_src dst2]，匹中tund2。这时知道了tund2是p2p，由tund1代之和dst2通信（先把缓存的最后一个包发过去）。
+#
 module Girl
   class Udp
 
@@ -24,31 +61,30 @@ module Girl
       redir.bind( Socket.sockaddr_in( redir_port, '0.0.0.0' ) )
       puts "redir bound on #{ redir_port } #{ Time.new }"
 
-      udp = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
-      udp.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-      udp.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
-      puts "udp bound on #{ udp.local_address.ip_unpack.last } #{ Time.new }"
-
       @mutex = Mutex.new
+      @udpd_host = udpd_host
       @udpd_addr = Socket.sockaddr_in( udpd_port, udpd_host )
       @ctlw = ctlw
       @redir = redir
-      @udp = udp
-      @reads = [ ctlr, redir, udp ]
+      @reads = [ ctlr, redir ]
       @writes = []
       @closings = []
       @roles = {
-        ctlr => :ctlr, # :ctlr / :redir / :udp / :src
-        redir => :redir,
-        udp => :udp
+        ctlr => :ctlr,   # :ctlr / :redir / :tun
+        redir => :redir
       }
-      @srcs = {}      # sd_addr => src
-      @src_infos = {} # src => {}
-                      #   sd_addr: [ src_addr, dest_addr ].join
-                      #   src_addr: src_addr
-                      #   dest_addr: dest_addr
-                      #   last_traff_at: now
-      @half = nil     # [ dest_addr, src_addr ].join
+      @redir_wbuffs = [] # [ src_addr data ] ...
+      @tuns = {}         # [ orig_src_addr dest_addr ] => tun
+      @tun_infos = {}    # tun => {}
+                         #   orig_src_addr: sockaddr
+                         #   dest_addr: sockaddr
+                         #   src_addr: sockaddr
+                         #   tun_addr: sockaddr
+                         #   tund_addr: sockaddr
+                         #   ctlmsgs: []
+                         #   wbuffs: []
+                         #   dest_rbuffs: []
+                         #   last_traff_at: now
     end
 
     def looping
@@ -64,15 +100,18 @@ module Girl
               read_ctlr( sock )
             when :redir
               read_redir( sock )
-            when :udp
-              read_udp( sock )
-            when :src
-              read_src( sock )
+            when :tun
+              read_tun( sock )
             end
           end
 
           ws.each do | sock |
-            write_src( sock )
+            case @roles[ sock ]
+            when :redir
+              write_redir( sock )
+            when :tun
+              write_tun( sock )
+            end
           end
         end
       end
@@ -85,144 +124,215 @@ module Girl
     private
 
     def read_ctlr( ctlr )
-      sd_addr = ctlr.read( 32 )
-      src = @srcs[ sd_addr ]
+      od_addr = ctlr.read( 32 )
+      tun = @tuns[ od_addr ]
 
-      if src
-        add_closing( src )
+      if tun
+        add_closing( tun )
       end
     end
 
     def read_redir( redir )
       data, addrinfo, rflags, *controls = redir.recvmsg
-
       src_addr = addrinfo.to_sockaddr
-      rows = IO.readlines( '/proc/net/nf_conntrack' ).reverse.map{ | line | line.split( ' ' ) }
-      row = rows.find{ | row | row[ 9 ] == '[UNREPLIED]' && row[ 2 ] == 'udp' && row[ 7 ].split( '=' )[ 1 ].to_i == addrinfo.ip_port && row[ 5 ].split( '=' )[ 1 ] == addrinfo.ip_address }
+
+      # puts "debug redir recv #{ data.inspect } from #{ addrinfo.inspect }"
+      # 2 udp 5 src 7 sport 9 [UNREPLIED] 11 dst 13 dport
+      # 2 udp 5 src 7 sport 10 dst 12 dport
+      bin = IO.binread( '/proc/net/nf_conntrack' )
+      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 #{ addrinfo.inspect } #{ Time.new }"
+        puts "miss conntrack #{ addrinfo.inspect } #{ Time.new }"
+        IO.binwrite( '/tmp/nf_conntrack', bin )
         return
       end
 
-      dest_addr = Socket.sockaddr_in( row[ 8 ].split( '=' )[ 1 ].to_i, row[ 6 ].split( '=' )[ 1 ] )
-      sendmsg_to_udpd( "#{ src_addr }#{ dest_addr }#{ data }" )
+      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 tun
+        tun_info = @tun_infos[ tun ]
+
+        unless tun_info[ :src_addr ]
+          # p2p paired
+          tun_info[ :src_addr ] = src_addr
+
+          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 ]
+
+        # 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
+        add_ctlmsg( tun, ctlmsg )
+      end
+
+      add_write( tun, data )
     end
 
-    def read_udp( udp )
-      data, addrinfo, rflags, *controls = udp.recvmsg
-      return if data.size < 32
+    def read_tun( tun )
+      data, addrinfo, rflags, *controls = tun.recvmsg
+      from_addr = addrinfo.to_sockaddr
+      tun_info = @tun_infos[ tun ]
+      tun_info[ :last_traff_at ] = Time.new
 
-      if @half.nil? && data.size == 32
-         @half = data
-         return
-      end
+      if from_addr == @udpd_addr
+        ctl_num = data[ 0 ].unpack( 'C' ).first
 
-      if @half
-        dest_addr = @half[ 0, 16 ]
-        src_addr = @half[ 16, 16 ]
-        @half = nil
-      else
-        dest_addr = data[ 0, 16 ]
-        src_addr = data[ 16, 16 ]
-        data = data[ 32..-1 ]
-      end
+        case ctl_num
+        when 2 # C: 2 (udpd > tun: tund port) -> n: tund_port -> tun_addr
+          return if tun_info[ :tund_addr ]
 
-      sd_addr = [ src_addr, dest_addr ].join
-      src = @srcs[ sd_addr ]
-
-      unless src
-        src = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
-        src.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-        src.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
-
-        @srcs[ sd_addr ] = src
-        @src_infos[ src ] = {
-          sd_addr: sd_addr,
-          src_addr: src_addr,
-          dest_addr: dest_addr,
-          wbuffs: [],
-          last_traff_at: Time.new
-        }
-
-        @roles[ src ] = :src
-        @reads << src
-      end
+          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
 
-      src_info = @src_infos[ src ]
-      src_info[ :wbuffs ] << data
-      add_write( src )
-    end
+          # 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
 
-    def read_src( src )
-      data, addrinfo, rflags, *controls = src.recvmsg
+          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 ]
 
-      src_info = @src_infos[ src ]
-      return unless src_info
+          unless chain_tun
+            chain_tun = new_a_tun( orig_src_addr, new_dest_addr )
+          end
 
-      src_info[ :last_traff_at ] = Time.new
-      src_addr = addrinfo.to_sockaddr
-      sendmsg_to_udpd( "#{ src_addr }#{ src_info[ :dest_addr ] }#{ data }" )
+          # 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
+      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
+      end
+    end
+
+    def write_redir( redir )
+      if @redir_wbuffs.empty?
+        @writes.delete( redir )
+        return
+      end
+
+      src_addr, data = @redir_wbuffs.shift
+      redir.sendmsg( data, 0, src_addr )
     end
 
-    def write_src( src )
-      if @closings.include?( src )
-        close_src( src )
+    def write_tun( tun )
+      if @closings.include?( tun )
+        close_tun( tun )
         return
       end
 
-      src_info = @src_infos[ src ]
-      data = src_info[ :wbuffs ].shift
+      tun_info = @tun_infos[ tun ]
+      ctlmsg = tun_info[ :ctlmsgs ].shift
 
-      unless data
-        @writes.delete( src )
+      if ctlmsg
+        tun.sendmsg( ctlmsg, 0, @udpd_addr )
         return
       end
 
-      begin
-        src.sendmsg( data, 0, src_info[ :src_addr ] )
-      rescue Errno::EACCES, Errno::EINTR => e
-        puts "src sendmsg #{ e.class } #{ Time.new }"
-        add_closing( src )
+      if tun_info[ :tund_addr ].nil? || tun_info[ :wbuffs ].empty?
+        @writes.delete( tun )
         return
       end
 
-      src_info[ :last_traff_at ] = Time.new
+      data = tun_info[ :wbuffs ].shift
+      tun.sendmsg( data, 0, tun_info[ :tund_addr ] )
     end
 
-    def add_write( src )
-      unless @writes.include?( src )
-        @writes << src
+    def add_ctlmsg( tun, ctlmsg )
+      tun_info = @tun_infos[ tun ]
+      tun_info[ :ctlmsgs ] << ctlmsg
+
+      unless @writes.include?( tun )
+        @writes << tun
       end
     end
 
-    def add_closing( src )
-      unless @closings.include?( src )
-        @closings << src
+    def add_write( tun, data = nil )
+      tun_info = @tun_infos[ tun ]
+
+      if data
+        tun_info[ :wbuffs ] << data
       end
 
-      add_write( src )
+      unless @writes.include?( tun )
+        @writes << tun
+      end
     end
 
-    def close_src( src )
-      src.close
-      @reads.delete( src )
-      @writes.delete( src )
-      @closings.delete( src )
-      @roles.delete( src )
-      src_info = @src_infos.delete( src )
-      @srcs.delete( src_info[ :sd_addr ] )
+    def add_redir_write( redir )
+      unless @writes.include?( redir )
+        @writes << redir
+      end
     end
 
-    def sendmsg_to_udpd( data )
-      begin
-        @udp.sendmsg( data, 0, @udpd_addr )
-      rescue Errno::EMSGSIZE => e
-        puts "#{ e.class } #{ Time.new }"
-        [ data[ 0, 32 ], data[ 32..-1 ] ].each do | part |
-          @udp.sendmsg( part, 0, @udpd_addr )
-        end
+    def add_closing( tun )
+      unless @closings.include?( tun )
+        @closings << tun
       end
+
+      add_write( tun )
+    end
+
+    def close_tun( tun )
+      tun.close
+      @reads.delete( tun )
+      @writes.delete( tun )
+      @closings.delete( tun )
+      @roles.delete( tun )
+      tun_info = @tun_infos.delete( tun )
+      @tuns.delete( [ tun_info[ :orig_src_addr ], tun_info[ :dest_addr ] ].join )
+    end
+
+    def new_a_tun( orig_src_addr, dest_addr, src_addr = nil )
+      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,
+        src_addr: src_addr,
+        tun_addr: nil,
+        tund_addr: nil,
+        ctlmsgs: [],
+        wbuffs: [],
+        dest_rbuffs: [],
+        last_traff_at: Time.new
+      }
+
+      @roles[ tun ] = :tun
+      @reads << tun
+
+      tun
     end
 
     def loop_expire
@@ -233,9 +343,9 @@ module Girl
           @mutex.synchronize do
             now = Time.new
 
-            @src_infos.values.each do | src_info |
-              if now - src_info[ :last_traff_at ] > 1800
-                @ctlw.write( src_info[ :sd_addr ] )
+            @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 )
               end
             end
           end

data/lib/girl/udpd.rb

@@ -22,16 +22,25 @@ module Girl
       @writes = []
       @closings = []
       @roles = {
-        ctlr => :ctlr, # :ctlr / :udpd / :dest
+        ctlr => :ctlr,        # :ctlr / :udpd / :tund
         udpd => :udpd
       }
-      @dests = {}      # us_addr => dest
-      @dest_infos = {} # dest => {}
-                       #   us_addr: [ udp_addr, src_addr ].join
-                       #   udp_addr: udp_addr
-                       #   src_addr: src_addr
-                       #   last_traff_at: now
-      @halfs = {}      # udp_addr => [ src_addr, dest_addr ].join
+      @udpd_wbuffs = []       # [ tun_addr ctlmsg ] ...
+      @tunds = {}             # [ tun_ip_addr orig_src_addr dest_addr ] => tund
+      @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 => [] }
+                              #   last_traff_at: now
+      @od_addr_rbuffs = {}
     end
 
     def looping
@@ -47,13 +56,18 @@ module Girl
               read_ctlr( sock )
             when :udpd
               read_udpd( sock )
-            when :dest
-              read_dest( sock )
+            when :tund
+              read_tund( sock )
             end
           end
 
           ws.each do | sock |
-            write_dest( sock )
+            case @roles[ sock ]
+            when :udpd
+              write_udpd( sock )
+            when :tund
+              write_tund( sock )
+            end
           end
         end
       end
@@ -66,138 +80,229 @@ module Girl
     private
 
     def read_ctlr( ctlr )
-      us_addr = ctlr.read( 32 )
-      dest = @dests[ us_addr ]
+      tod_addr = ctlr.read( 48 )
+      tund = @tunds[ tod_addr ]
 
-      if dest
-        # puts "debug expire dest #{ us_addr.inspect } #{ Time.new }"
-        add_closing( dest )
+      if tund
+        add_closing( tund )
       end
     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
-      return if data.size < 32
+      # 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 ]
+      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?
 
-      udp_addr = addrinfo.to_sockaddr
+      tund = @tunds[ [ tun_ip_addr, orig_src_addr, dest_addr ].join ]
 
-      if @halfs[ udp_addr ].nil? && data.size == 32
-         @halfs[ udp_addr ] = data
-         return
-      end
+      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?
 
-      if @halfs[ udp_addr ]
-        src_addr = @halfs[ udp_addr ][ 0, 16 ]
-        dest_addr = @halfs[ udp_addr ][ 16, 16 ]
-        data = "#{ dest_addr }#{ data }"
-        @halfs.delete( udp_addr )
-      else
-        src_addr = data[ 0, 16 ]
-        dest_addr = data[ 16, 16 ]
-        data = data[ 16..-1 ]
-      end
+        root_tund = @tunds[ [ tun_ip_addr, orig_src_addr, root_dest_addr ].join ]
 
-      return unless Addrinfo.new( src_addr ).ipv4?
-      return unless Addrinfo.new( dest_addr ).ipv4?
+        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
 
-      us_addr = [ udp_addr, src_addr ].join
-      dest = @dests[ us_addr ]
-
-      unless dest
-        dest = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
-        dest.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 1 )
-        dest.bind( Socket.sockaddr_in( 0, '0.0.0.0' ) )
-
-        @dests[ us_addr ] = dest
-        @dest_infos[ dest ] = {
-          us_addr: us_addr,
-          udp_addr: udp_addr,
-          src_addr: src_addr,
-          wbuffs: [],
-          last_traff_at: Time.new
-        }
-
-        @roles[ dest ] = :dest
-        @reads << dest
+        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
       end
 
-      dest_info = @dest_infos[ dest ]
-      dest_info[ :wbuffs ] << data
-      add_write( dest )
+      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
     end
 
-    def read_dest( dest )
-      data, addrinfo, rflags, *controls = dest.recvmsg
+    def read_tund( tund )
+      data, addrinfo, rflags, *controls = tund.recvmsg
+      from_addr = addrinfo.to_sockaddr
+      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 ]
+
+        if !tund_info[ :is_tunneled ]
+          tund_info[ :is_tunneled ] = true
+
+          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 dest_rbuffs
+              # puts "debug #{ Addrinfo.new( tund_info[ :dest_addr ] ).inspect } dest_rbuffs #{ dest_rbuffs.inspect }"
+              tund_info[ :wbuffs ] = dest_rbuffs
+              add_write( tund )
+            end
+
+            if data.size == 1 && data[ 0 ].unpack( 'C' ).first == 5
+              puts "ignore C: 5 (hello) #{ Time.new }"
+              return
+            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
 
-      dest_info = @dest_infos[ dest ]
-      return unless dest_info
+          tund_info[ :dest_wmemos ] << data
+        end
+      elsif from_addr == tund_info[ :dest_addr ]
+        tund_info[ :is_dest_responsed ] = true
+        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 ]
 
-      dest_info[ :last_traff_at ] = Time.new
-      dest_addr = addrinfo.to_sockaddr
-      sendmsg_to_udp( "#{ dest_addr }#{ dest_info[ :src_addr ] }#{ data }", dest_info[ :udp_addr ] )
+        unless chain_tund
+          unless tund_info[ :new_dest_rbuffs ].include?( from_addr )
+            tund_info[ :new_dest_rbuffs ][ from_addr ] = []
+          end
+
+          tund_info[ :new_dest_rbuffs ][ from_addr ] << data
+
+          # 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
+
+        chain_tund_info = @tund_infos[ chain_tund ]
+
+        unless chain_tund_info[ :root_tund ]
+          # p2p paired
+          chain_tund_info[ :root_tund ] = tund
+
+          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 )
+            end
+
+            chain_tund_info[ :dest_wmemos ].clear
+          end
+        end
+
+        add_write( chain_tund, data )
+      end
     end
 
-    def write_dest( dest )
-      if @closings.include?( dest )
-        close_dest( dest )
+    def write_udpd( udpd )
+      if @udpd_wbuffs.empty?
+        @writes.delete( udpd )
         return
       end
 
-      dest_info = @dest_infos[ dest ]
-      data = dest_info[ :wbuffs ].shift
+      tun_addr, ctlmsg = @udpd_wbuffs.shift
+      udpd.sendmsg( ctlmsg, 0, tun_addr )
+    end
 
-      unless data
-        @writes.delete( dest )
+    def write_tund( tund )
+      if @closings.include?( tund )
+        close_tund( tund )
         return
       end
 
-      dest_addr = data[ 0, 16 ]
-      data = data[ 16..-1 ]
+      tund_info = @tund_infos[ tund ]
 
-      begin
-        dest.sendmsg( data, 0, dest_addr )
-      rescue Errno::EACCES, Errno::EINTR => e
-        puts "dest sendmsg #{ e.class } #{ Time.new }"
-        add_closing( dest )
+      if tund_info[ :wbuffs ].empty?
+        @writes.delete( tund )
         return
       end
 
-      dest_info[ :last_traff_at ] = Time.new
+      data = tund_info[ :wbuffs ].shift
+      tund.sendmsg( data, 0, tund_info[ :tun_addr ] )
     end
 
-    def add_write( dest )
-      unless @writes.include?( dest )
-        @writes << dest
+    def add_write( tund, data = nil )
+      tund_info = @tund_infos[ tund ]
+
+      if data
+        tund_info[ :wbuffs ] << data
+      end
+
+      if tund_info[ :tun_addr ] && !@writes.include?( tund )
+        @writes << tund
       end
     end
 
-    def add_closing( dest )
-      unless @closings.include?( dest )
-        @closings << dest
+    def add_closing( tund )
+      unless @closings.include?( tund )
+        @closings << tund
       end
 
-      add_write( dest )
+      add_write( tund )
     end
 
-    def close_dest( dest )
-      dest.close
-      @reads.delete( dest )
-      @writes.delete( dest )
-      @closings.delete( dest )
-      @roles.delete( dest )
-      dest_info = @dest_infos.delete( dest )
-      @dests.delete( dest_info[ :us_addr ] )
+    def close_tund( tund )
+      tund.close
+      @reads.delete( tund )
+      @writes.delete( tund )
+      @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 )
     end
 
-    def sendmsg_to_udp( data, udp_addr )
-      begin
-        @udpd.sendmsg( data, 0, udp_addr )
-      rescue Errno::EMSGSIZE => e
-        puts "#{ e.class } #{ Time.new }"
-        [ data[ 0, 32 ], data[ 32..-1 ] ].each do | part |
-          @udpd.sendmsg( part, 0, udp_addr )
-        end
-      end
+    def new_a_tund( tun_addr, tun_ip_addr, orig_src_addr, dest_addr, root_tund = nil )
+      tund = Socket.new( Socket::AF_INET, Socket::SOCK_DGRAM, 0 )
+      tund.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEPORT, 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
+      @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,
+        wbuffs: [],
+        is_dest_responsed: root_tund ? true : false,
+        dest_wmemos: [],
+        new_dest_rbuffs: {},
+        last_traff_at: Time.new
+      }
+
+      @roles[ tund ] = :tund
+      @reads << tund
+
+      tund
     end
 
     def loop_expire
@@ -208,9 +313,9 @@ module Girl
           @mutex.synchronize do
             now = Time.new
 
-            @dest_infos.values.each do | dest_info |
-              if now - dest_info[ :last_traff_at ] > 1800
-                @ctlw.write( dest_info[ :us_addr ] )
+            @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 )
               end
             end
           end

data/lib/girl/version.rb

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

metadata

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